From 639f637a7249da6b67b9e8ff2c41fc41ec4a9cd3 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 11:18:46 +0000 Subject: [PATCH 1/6] Update Aiur to Plonky3 0.6 Update the multi-stark dependency and Rust toolchain for Plonky3 0.6, along with the Rust 1.98 lint migrations required to keep the workspace warning-free. Refresh the Rust-compatible Blake3.lean pin in both root and compile-package manifests. Adapt recursive Aiur verification to Plonky3's pruned FRI multiproofs. Native proofs retain their compact serialized representation and native verification path; the FFI expands authenticated Merkle frontiers into per-query advice only when entering the existing recursive verifier circuit. Preserve the packed claim-digest convention in the recursion diagnostic and exercise the advice boundary in the end-to-end test and benchmark paths. CPU and CUDA recursive q1 runs produce identical 823,485-byte inner proofs and 331,273-byte outer proofs. The q50 Vector.extract_append workload retains identical CPU/CUDA proof sizes. Inner plus outer STARK proving measures 65.87s on CPU and 8.81s with CUDA on the RTX PRO 6000, a 7.48x speedup. --- Benchmarks/Compile/lake-manifest.json | 4 +- Benchmarks/RecursionDebug.lean | 14 +- Benchmarks/Typecheck.lean | 11 +- Cargo.lock | 214 ++++++++++-------- Cargo.toml | 3 +- Ix/Aiur/Protocol.lean | 6 + Tests/MultiStark.lean | 6 +- crates/aiur/src/execute.rs | 6 +- crates/aiur/src/gadgets/bytes1.rs | 15 +- crates/aiur/src/gadgets/bytes2.rs | 4 +- crates/aiur/src/synthesis.rs | 16 ++ crates/common/src/address.rs | 6 +- crates/compile/src/compile.rs | 2 +- crates/compile/src/compile/aux_gen/brecon.rs | 6 +- .../compile/src/compile/aux_gen/cases_on.rs | 2 +- crates/compile/src/compile/env.rs | 2 +- crates/compile/src/compile/mutual.rs | 24 +- crates/ffi/src/aiur/protocol.rs | 23 +- crates/ffi/src/catalog.rs | 10 +- crates/ffi/src/kernel.rs | 2 +- crates/ffi/src/lean_env.rs | 4 +- crates/ffi/src/lean_ixon/sharing.rs | 2 +- crates/ixon/src/diff.rs | 2 +- crates/ixvm-codegen/src/aiur_ixvm_witness.rs | 4 +- crates/kernel/src/def_eq.rs | 4 +- crates/kernel/src/inductive.rs | 8 +- crates/kernel/src/ingress.rs | 12 +- crates/kernel/src/perf.rs | 2 +- crates/kernel/src/tc.rs | 3 +- crates/kernel/src/whnf.rs | 6 +- flake.lock | 8 +- flake.nix | 4 +- lake-manifest.json | 4 +- lakefile.lean | 2 +- rust-toolchain.toml | 2 +- 35 files changed, 250 insertions(+), 193 deletions(-) diff --git a/Benchmarks/Compile/lake-manifest.json b/Benchmarks/Compile/lake-manifest.json index 5ffda5058..74b77d83a 100644 --- a/Benchmarks/Compile/lake-manifest.json +++ b/Benchmarks/Compile/lake-manifest.json @@ -182,10 +182,10 @@ "type": "git", "subDir": null, "scope": "", - "rev": "db25a8a21579d8211eec4347402721f5674bf2c1", + "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "name": "Blake3", "manifestFile": "lake-manifest.json", - "inputRev": "db25a8a21579d8211eec4347402721f5674bf2c1", + "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "inherited": true, "configFile": "lakefile.lean"}, {"url": "https://github.com/argumentcomputer/LSpec", diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean index 41167de24..ec4a059b7 100644 --- a/Benchmarks/RecursionDebug.lean +++ b/Benchmarks/RecursionDebug.lean @@ -102,19 +102,21 @@ def proveConst (ixePath constName : String) (skipDeps : Bool) match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash with | .error e => IO.eprintln s!"proveAddrWithEnv failed: {e}"; return none | .ok (claimBytes, proof, _) => - -- `verify_claim`'s public input is the 32-G blake3 digest of the - -- serialized `Ix.Claim` (same recipe as `ix verify` / bench-typecheck). + -- `verify_claim` takes the packed Blake3 digest used by the + -- production typecheck path: eight field elements of four bytes. let digest := Address.blake3 claimBytes - pure (Aiur.buildClaim funIdx (digest.hash.data.map .ofUInt8) #[], proof) + pure (Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[], proof) let t1 ← IO.monoNanosNow - let proofBytes := proof.toBytes - IO.println s!"inner prove: {secs t0 t1} s, proof {proofBytes.size} bytes" + IO.println s!"inner prove: {secs t0 t1} s, proof {proof.toBytes.size} bytes" -- Sanity: the inner proof must verify out-of-circuit before we chase the -- recursive verifier. match aiurSystem.verify claim proof with | .ok () => IO.println "inner proof verifies out-of-circuit: ok" | .error e => IO.eprintln s!"⚠ inner proof FAILS out-of-circuit verify: {e}" - return some (proofBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim]) + match aiurSystem.proofToAdviceBytes claim proof with + | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return none + | .ok adviceBytes => + return some (adviceBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim]) def main (args : List String) : IO UInt32 := do let ixePath := (argStr args "--ixe").getD "init.ixe" diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 177905eae..359323bcf 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -592,10 +592,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let claimBytes := MultiStark.serializeClaims #[claim] let vkBytes := aiurSystem.vkBytes let pubInput := MultiStark.verifierPubInput vkBytes claimBytes + -- Native proof bytes use P3's pruned multiproof format. The + -- in-circuit verifier consumes equivalent per-query path advice. + let adviceBytes ← match aiurSystem.proofToAdviceBytes claim proof with + | .ok bytes => pure bytes + | .error e => + IO.eprintln s!" ❌ advice re-encoding for {r.name} FAILED: {e}" + continue -- Native path: the advice buffer is built in Rust from the raw -- byte blobs and execution routes through the codegen'd verifier. let (rvRes, rvSec) ← timed fun _ => - vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes + vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes vkBytes claimBytes useInterp match rvRes with | .error e => @@ -621,7 +628,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do (← IO.getStdout).flush TracingTexray.resetPeakTreeRss let (rvProveRes, rvProveSec) ← timed fun _ => - vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes + vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes claimBytes useInterp let (rvClaim, rvProof) ← match rvProveRes with | .ok result => pure result diff --git a/Cargo.lock b/Cargo.lock index db881f753..0141466ef 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -54,7 +54,7 @@ dependencies = [ "indexmap", "libc", "multi-stark", - "num-bigint", + "num-bigint 0.4.6", "rayon", "rustc-hash", "tracing", @@ -192,7 +192,7 @@ name = "bignat" version = "0.1.0" source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5" dependencies = [ - "num-bigint", + "num-bigint 0.4.6", ] [[package]] @@ -331,6 +331,17 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "rand_core 0.10.1", +] + [[package]] name = "chrono" version = "0.4.44" @@ -1735,6 +1746,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc" +dependencies = [ + "either", +] + [[package]] name = "itoa" version = "1.0.18" @@ -1774,7 +1794,7 @@ dependencies = [ "ix-common", "ix-kernel", "ixon", - "num-bigint", + "num-bigint 0.4.6", "rayon", "rustc-hash", "sha2 0.10.9", @@ -1807,7 +1827,7 @@ dependencies = [ "mimalloc", "multi-stark", "n0-error", - "num-bigint", + "num-bigint 0.4.6", "rayon", "rustc-hash", "serde", @@ -1839,7 +1859,7 @@ dependencies = [ "ix-common", "ixon", "log", - "num-bigint", + "num-bigint 0.4.6", "quickcheck", "quickcheck_macros", "rayon", @@ -1857,7 +1877,7 @@ dependencies = [ "ix-common", "memmap2", "nom", - "num-bigint", + "num-bigint 0.4.6", "quickcheck", "quickcheck_macros", "rayon", @@ -1875,7 +1895,7 @@ dependencies = [ "ix-common", "ixon", "multi-stark", - "num-bigint", + "num-bigint 0.4.6", "rayon", "rustc-hash", "stacker", @@ -1907,7 +1927,7 @@ dependencies = [ "bignat", "bindgen", "cc", - "num-bigint", + "num-bigint 0.4.6", ] [[package]] @@ -2084,7 +2104,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=e43201522a95775d1495b4467fbab69fbf7a1ae8#e43201522a95775d1495b4467fbab69fbf7a1ae8" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=33b4454aa63b88427b3d3cc09980fe86ddeb7e5f#33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" dependencies = [ "bincode", "itertools 0.14.0", @@ -2096,7 +2116,6 @@ dependencies = [ "p3-field", "p3-fri", "p3-goldilocks", - "p3-interpolation", "p3-keccak", "p3-matrix", "p3-maybe-rayon", @@ -2371,6 +2390,16 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-bigint" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0" +dependencies = [ + "num-integer", + "num-traits", +] + [[package]] name = "num-conv" version = "0.2.1" @@ -2506,18 +2535,19 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "p3-air" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-matrix", + "serde", "tracing", ] [[package]] name = "p3-blake3" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "blake3", "p3-symmetric", @@ -2526,12 +2556,11 @@ dependencies = [ [[package]] name = "p3-challenger" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-maybe-rayon", - "p3-monty-31", "p3-symmetric", "p3-util", "tracing", @@ -2539,40 +2568,39 @@ dependencies = [ [[package]] name = "p3-commit" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", - "p3-challenger", + "itertools 0.15.0", "p3-dft", "p3-field", - "p3-interpolation", "p3-matrix", + "p3-multilinear-util", "p3-util", "serde", ] [[package]] name = "p3-dft" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-field", "p3-matrix", "p3-maybe-rayon", "p3-util", - "spin 0.10.1", + "spin 0.12.3", "tracing", ] [[package]] name = "p3-field" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", - "num-bigint", + "itertools 0.15.0", + "num-bigint 0.5.1", "p3-maybe-rayon", "p3-util", "paste", @@ -2583,32 +2611,31 @@ dependencies = [ [[package]] name = "p3-fri" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-challenger", "p3-commit", "p3-dft", "p3-field", - "p3-interpolation", "p3-matrix", "p3-maybe-rayon", + "p3-security", "p3-util", "rand 0.10.1", "serde", - "spin 0.10.1", + "spin 0.12.3", "thiserror", "tracing", ] [[package]] name = "p3-goldilocks" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "num-bigint", - "p3-challenger", + "num-bigint 0.5.1", "p3-dft", "p3-field", "p3-mds", @@ -2619,23 +2646,13 @@ dependencies = [ "paste", "rand 0.10.1", "serde", -] - -[[package]] -name = "p3-interpolation" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" -dependencies = [ - "p3-field", - "p3-matrix", - "p3-maybe-rayon", - "p3-util", + "spin 0.12.3", ] [[package]] name = "p3-keccak" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-symmetric", "p3-util", @@ -2644,10 +2661,10 @@ dependencies = [ [[package]] name = "p3-matrix" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-field", "p3-maybe-rayon", "p3-util", @@ -2658,16 +2675,16 @@ dependencies = [ [[package]] name = "p3-maybe-rayon" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "rayon", ] [[package]] name = "p3-mds" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-dft", "p3-field", @@ -2678,10 +2695,10 @@ dependencies = [ [[package]] name = "p3-merkle-tree" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-commit", "p3-field", "p3-matrix", @@ -2690,47 +2707,41 @@ dependencies = [ "p3-util", "rand 0.10.1", "serde", + "spin 0.12.3", "thiserror", "tracing", ] [[package]] -name = "p3-monty-31" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +name = "p3-multilinear-util" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", - "num-bigint", - "p3-dft", + "itertools 0.15.0", "p3-field", "p3-matrix", "p3-maybe-rayon", - "p3-mds", - "p3-poseidon1", - "p3-poseidon2", - "p3-symmetric", "p3-util", - "paste", "rand 0.10.1", "serde", - "spin 0.10.1", "tracing", ] [[package]] name = "p3-poseidon1" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", + "p3-mds", "p3-symmetric", "rand 0.10.1", ] [[package]] name = "p3-poseidon2" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-mds", @@ -2739,12 +2750,24 @@ dependencies = [ "rand 0.10.1", ] +[[package]] +name = "p3-security" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +dependencies = [ + "libm", + "p3-air", + "p3-field", + "p3-util", + "serde", +] + [[package]] name = "p3-symmetric" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-field", "p3-util", "serde", @@ -2752,11 +2775,11 @@ dependencies = [ [[package]] name = "p3-util" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ + "p3-maybe-rayon", "serde", - "transpose", ] [[package]] @@ -3158,6 +3181,7 @@ version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" dependencies = [ + "chacha20", "getrandom 0.4.2", "rand_core 0.10.1", ] @@ -3614,6 +3638,12 @@ name = "spin" version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3" + +[[package]] +name = "spin" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10" dependencies = [ "lock_api", ] @@ -3647,12 +3677,6 @@ dependencies = [ "windows-sys 0.61.2", ] -[[package]] -name = "strength_reduce" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82" - [[package]] name = "strsim" version = "0.11.1" @@ -4064,16 +4088,6 @@ dependencies = [ "tracing-subscriber", ] -[[package]] -name = "transpose" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e" -dependencies = [ - "num-integer", - "strength_reduce", -] - [[package]] name = "try-lock" version = "0.2.5" diff --git a/Cargo.toml b/Cargo.toml index 1791ae265..70d17d38e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,7 +56,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "e43201522a95775d1495b4467fbab69fbf7a1ae8" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" @@ -98,7 +98,6 @@ filter_map_next = "warn" flat_map_option = "warn" fn_to_numeric_cast = "warn" fn_to_numeric_cast_with_truncation = "warn" -from_iter_instead_of_collect = "warn" implicit_clone = "warn" inefficient_to_string = "warn" invalid_upcast_comparisons = "warn" diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 412ad59ea..43ce405ec 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -189,6 +189,12 @@ def shardProveWithEnv (system : @& AiurSystem) opaque verify : @& AiurSystem → @& Array G → @& Proof → Except String Unit +/-- Re-encode a natively valid proof into the per-query Merkle-path advice +transport consumed by the in-circuit recursive verifier. -/ +@[extern "rs_aiur_proof_to_advice_bytes"] +opaque proofToAdviceBytes : @& AiurSystem → + @& Array G → @& Proof → Except String ByteArray + end AiurSystem namespace Bytecode.Toplevel diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 26d62327d..4e36fa670 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -157,7 +157,9 @@ def endToEndSuite : IO UInt32 := do | .ok result => pure result | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1 let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120] - let proofBytes := proof.toBytes + let proofBytes ← match facSystem.proofToAdviceBytes claim proof with + | .ok bytes => pure bytes + | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return 1 -- ── serialize proof (advice) + vk + claims, with public Blake3 digests ── let proofGs : Array Aiur.G := proofBytes.data.map .ofUInt8 @@ -201,7 +203,7 @@ def endToEndSuite : IO UInt32 := do -- ── run the (expensive) checks, then assert ───────────────────────────────── IO.println "recursive-verifier (proving + recursive verification, ~1.5 min)…" - let innerVerify := facSystem.verify claim (.ofBytes proofBytes) + let innerVerify := facSystem.verify claim (.ofBytes proof.toBytes) -- Native path: Rust-built advice buffer + codegen'd verifier -- (`crates/ixvm-codegen/src/aiur_multi_stark.rs`). let honest := diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 3037a1d52..d5d847c95 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -209,7 +209,7 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) { .map(|(i, m)| (i, m.len(), m.retained_elems())) .filter(|(_, n, _)| *n > 0) .collect(); - rows.sort_by(|a, b| b.2.cmp(&a.2)); + rows.sort_by_key(|row| std::cmp::Reverse(row.2)); let total_entries: usize = rows.iter().map(|r| r.1).sum(); let total_elems: usize = rows.iter().map(|r| r.2).sum(); eprintln!( @@ -1053,7 +1053,9 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec { bytes.push(0); } bytes - .chunks_exact(8) + .as_chunks::<8>() + .0 + .iter() .map(|c| { let mut a = [0u8; 8]; a.copy_from_slice(c); diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index 667cb8ad9..e3acd1552 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -49,8 +49,12 @@ impl AiurGadget for Bytes1 { /// Builds the preprocessed trace over all 256 byte values. fn preprocessed(&self) -> Option> { let mut values = vec![G::ZERO; 256 * PREPROCESSED_TRACE_WIDTH]; - values.chunks_exact_mut(PREPROCESSED_TRACE_WIDTH).enumerate().for_each( - |(i, row)| { + values + .as_chunks_mut::() + .0 + .iter_mut() + .enumerate() + .for_each(|(i, row)| { let byte = G::from_usize(i); // Raw byte value @@ -68,8 +72,7 @@ impl AiurGadget for Bytes1 { // Byte shifted right row[10] = Self::shift_right(&byte); - }, - ); + }); Some(RowMajorMatrix::new(values, PREPROCESSED_TRACE_WIDTH)) } @@ -168,7 +171,9 @@ impl AiurGadget for Bytes1 { // There are at most 256 rows so parallelism is not necessay. rows - .chunks_exact_mut(TRACE_WIDTH) + .as_chunks_mut::() + .0 + .iter_mut() .enumerate() .zip(&record.bytes1_queries.0) .zip(row_writers.iter_mut()) diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index 8a2e16ef4..e013a6a34 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -304,7 +304,9 @@ impl AiurGadget for Bytes2 { let xor_split4_channel = u8_xor_split4_channel(); rows - .chunks_exact_mut(TRACE_WIDTH) + .as_chunks_mut::() + .0 + .iter_mut() .enumerate() .zip(&record.bytes2_queries.0) .zip(row_writers.iter_mut()) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 552743c28..70e598184 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -443,6 +443,22 @@ impl AiurSystem { ) -> Result<(), VerificationError> { self.system.verify(claim, proof) } + + /// Re-encode a verified proof into the per-query authentication-path + /// transport consumed by the in-circuit recursive verifier. + pub fn proof_to_advice_bytes( + &self, + claim: &[G], + proof: &AiurProof, + ) -> Result, multi_stark::advice::AdviceError> { + multi_stark::advice::proof_to_advice_bytes( + &self.system, + self.commitment_parameters, + self.fri_parameters, + &[claim], + proof, + ) + } } #[cfg(test)] diff --git a/crates/common/src/address.rs b/crates/common/src/address.rs index 334aafd13..0bc032456 100644 --- a/crates/common/src/address.rs +++ b/crates/common/src/address.rs @@ -46,10 +46,12 @@ impl Address { } /// Iterate addresses out of a flat `[u8; 32 * N]` byte blob. Trailing - /// bytes shorter than 32 are silently dropped (via `chunks_exact`). + /// bytes shorter than 32 are silently dropped. pub fn unpack(bytes: &[u8]) -> impl Iterator + '_ { bytes - .chunks_exact(32) + .as_chunks::<32>() + .0 + .iter() .map(|c| Address::from_slice(c).expect("malformed address chunk")) } diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs index b07bb3526..cae62d132 100644 --- a/crates/compile/src/compile.rs +++ b/crates/compile/src/compile.rs @@ -1209,7 +1209,7 @@ pub fn compile_expr( }); } let n_specs = specs.len(); - canonical_args.extend(specs.into_iter()); + canonical_args.extend(specs); for (src_i, motive) in motives.iter().enumerate() { if plan.motive_keep[src_i] { canonical_args.push(motive.clone()); diff --git a/crates/compile/src/compile/aux_gen/brecon.rs b/crates/compile/src/compile/aux_gen/brecon.rs index ee9134edb..da2db5172 100644 --- a/crates/compile/src/compile/aux_gen/brecon.rs +++ b/crates/compile/src/compile/aux_gen/brecon.rs @@ -510,8 +510,7 @@ fn build_prop_below_minor_fvar( let mut lambda_fvars: Vec = Vec::new(); let mut ctor_args: Vec = Vec::new(); - for (fi, (decl, fvar)) in - field_decls.into_iter().zip(field_fvars.into_iter()).enumerate() + for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate() { if let Some(j_prime) = find_motive_fvar(&decl.domain, motive_fvars) { // IH field. For a non-reflexive IH `motive args`, the new binder is @@ -1134,8 +1133,7 @@ fn build_type_minor_premise_fvar( let mut lambda_fvars: Vec = Vec::new(); let mut prod_entries: Vec<(LeanExpr, usize)> = Vec::new(); // (fvar, lambda_index) for IH fields - for (fi, (decl, fvar)) in - field_decls.into_iter().zip(field_fvars.into_iter()).enumerate() + for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate() { if let Some(_j_prime) = find_motive_fvar(&decl.domain, motive_fvars) { // IH field: replace domain with PProd(motive, below) diff --git a/crates/compile/src/compile/aux_gen/cases_on.rs b/crates/compile/src/compile/aux_gen/cases_on.rs index bad60eee0..096891920 100644 --- a/crates/compile/src/compile/aux_gen/cases_on.rs +++ b/crates/compile/src/compile/aux_gen/cases_on.rs @@ -191,7 +191,7 @@ pub fn generate_cases_on( let mut non_ih_fvars: Vec = Vec::new(); let mut wrapper_decls: Vec = Vec::new(); // all fields for the rec lambda - for (decl, fvar) in field_decls.into_iter().zip(field_fvars.into_iter()) { + for (decl, fvar) in field_decls.into_iter().zip(field_fvars) { let motive_idx = find_motive_fvar(&decl.domain, &motive_fvars); if let Some(idx) = motive_idx { if idx == target_idx { diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs index 2f4afa9f3..b30545b82 100644 --- a/crates/compile/src/compile/env.rs +++ b/crates/compile/src/compile/env.rs @@ -397,7 +397,7 @@ pub fn compile_env_with_options( // Use scoped threads to borrow from parent scope. `IX_COMPILE_WORKERS` // gives large-env callers a simple peak-memory/speed tradeoff knob. let available_threads = - thread::available_parallelism().map(|n| n.get()).unwrap_or(4); + thread::available_parallelism().map_or(4, |n| n.get()); let requested_threads = options.max_workers.or_else(|| { std::env::var("IX_COMPILE_WORKERS") .ok() diff --git a/crates/compile/src/compile/mutual.rs b/crates/compile/src/compile/mutual.rs index 17a67882a..e62050590 100644 --- a/crates/compile/src/compile/mutual.rs +++ b/crates/compile/src/compile/mutual.rs @@ -712,8 +712,8 @@ pub fn generate_and_compile_aux_recursors( // `populate_recursor_rules_from_block` comment in the kernel. let t1 = std::time::Instant::now(); let rec_consts: Vec = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::Rec(r) => Some(MutConst::Recr(r.clone())), _ => None, }) @@ -822,8 +822,8 @@ pub fn generate_and_compile_aux_recursors( // (because .brecOn.eq references casesOn). let t2 = std::time::Instant::now(); let cases_on_defs: Vec = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::CasesOn(d) => Some(MutConst::Defn(Def { name: d.name.clone(), level_params: d.level_params.clone(), @@ -846,8 +846,8 @@ pub fn generate_and_compile_aux_recursors( // recOn wraps .rec and must be compiled after .rec. let t3 = std::time::Instant::now(); let rec_on_defs: Vec = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::RecOn(d) => Some(MutConst::Defn(Def { name: d.name.clone(), level_params: d.level_params.clone(), @@ -887,8 +887,8 @@ pub fn generate_and_compile_aux_recursors( // order with the canonical `all`. let t4 = std::time::Instant::now(); let mut below_raw: Vec<&BelowIndc> = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::BelowIndc(bi) => Some(bi), _ => None, }) @@ -932,8 +932,8 @@ pub fn generate_and_compile_aux_recursors( // Phase 4: Compile .below definitions (Type-level). let below_defs: Vec = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::BelowDef(d) => Some(MutConst::Defn(Def { name: d.name.clone(), level_params: d.level_params.clone(), @@ -970,8 +970,8 @@ pub fn generate_and_compile_aux_recursors( let t6 = std::time::Instant::now(); for batch in 0..3u8 { let defs: Vec = patches - .iter() - .filter_map(|(_, p)| match p { + .values() + .filter_map(|p| match p { PatchedConstant::BRecOn(d) if brecon_batch(&d.name) == batch => { Some(brecon_to_mut_const(d)) }, diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 9adb0cd3c..167c8ace1 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -143,6 +143,21 @@ extern "C" fn rs_aiur_system_verify( } } +/// `AiurSystem.proofToAdviceBytes`: expand a valid pruned FRI multiproof into +/// the per-query advice transport consumed by the recursive verifier. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_proof_to_advice_bytes( + aiur_system_obj: LeanExternal>, + claim: LeanArray>, + proof_obj: LeanExternal>, +) -> LeanExcept { + let claim = claim.map(|x| lean_unbox_g(&x)); + match aiur_system_obj.get().proof_to_advice_bytes(&claim, proof_obj.get()) { + Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), + Err(err) => LeanExcept::error_string(&format!("{err:?}")), + } +} + /// `Bytecode.Toplevel.execute`: runs execution only (no proof) and returns /// `Except String ExecuteResult` (see `Ix/Aiur/Semantics/BytecodeFfi.lean`). /// On execution failure (e.g. assertion mismatch from a typechecker @@ -402,7 +417,9 @@ fn decode_owned_blob( } Ok( bytes - .chunks_exact(32) + .as_chunks::<32>() + .0 + .iter() .map(|c| ix_common::address::Address::from_slice(c).unwrap()) .collect(), ) @@ -685,7 +702,9 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( } shards.push( bytes[off..off + n * 32] - .chunks_exact(32) + .as_chunks::<32>() + .0 + .iter() .map(|c| ix_common::address::Address::from_slice(c).unwrap()) .collect(), ); diff --git a/crates/ffi/src/catalog.rs b/crates/ffi/src/catalog.rs index 6384a5836..f62e9ceef 100644 --- a/crates/ffi/src/catalog.rs +++ b/crates/ffi/src/catalog.rs @@ -127,9 +127,8 @@ pub extern "C" fn rs_catalog_assemble( return LeanIOResult::error_string(&format!("rs_catalog_assemble: {e}")); }, }; - let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE)) - .map(|m| m.len()) - .unwrap_or(0); + let manifest_bytes = + std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len()); let mut summary = catalog_json(&catalog); summary["bytes"] = serde_json::json!(manifest_bytes); summary["out"] = serde_json::json!(out_path); @@ -196,9 +195,8 @@ pub extern "C" fn rs_catalog_info( return LeanIOResult::error_string(&format!("rs_catalog_info: {e}")); }, }; - let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE)) - .map(|m| m.len()) - .unwrap_or(0); + let manifest_bytes = + std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len()); let mut summary = catalog_json(&catalog); summary["bytes"] = serde_json::json!(manifest_bytes); LeanIOResult::ok(LeanString::new(&summary.to_string())) diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 2185cad47..2b7807124 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -1296,7 +1296,7 @@ where fn resolve_kernel_check_workers(total: usize, quiet: bool) -> usize { let env_workers = std::env::var("IX_KERNEL_CHECK_WORKERS").ok(); let no_par = std::env::var("IX_NO_PAR").ok().as_deref() == Some("1"); - let available = thread::available_parallelism().map(|n| n.get()).unwrap_or(1); + let available = thread::available_parallelism().map_or(1, |n| n.get()); resolve_kernel_check_workers_from( total, quiet, diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs index 55dee3058..6c48ef5e6 100644 --- a/crates/ffi/src/lean_env.rs +++ b/crates/ffi/src/lean_env.rs @@ -4362,7 +4362,7 @@ fn analyze_const_size(stt: &ix_compile::compile::CompileState, name_str: &str) { } // Sort by total size descending - dep_breakdowns.sort_by(|a, b| b.1.total().cmp(&a.1.total())); + dep_breakdowns.sort_by_key(|entry| std::cmp::Reverse(entry.1.total())); let total_deps_alpha: usize = dep_breakdowns.iter().map(|(_, b)| b.alpha_size).sum(); @@ -4566,7 +4566,7 @@ fn analyze_block_size_stats(stt: &ix_compile::compile::CompileState) { .collect(); // Sort by overhead descending (most bloated first) - overheads.sort_by(|a, b| b.1.cmp(&a.1)); + overheads.sort_by_key(|entry| std::cmp::Reverse(entry.1)); // Compute statistics let avg_ratio = if total_hash_consed > 0 { diff --git a/crates/ffi/src/lean_ixon/sharing.rs b/crates/ffi/src/lean_ixon/sharing.rs index 9811fb63d..f49218f49 100644 --- a/crates/ffi/src/lean_ixon/sharing.rs +++ b/crates/ffi/src/lean_ixon/sharing.rs @@ -36,7 +36,7 @@ pub extern "C" fn rs_debug_sharing_analysis( .collect(); // Sort by usage count descending - candidates.sort_by(|a, b| b.1.usage_count.cmp(&a.1.usage_count)); + candidates.sort_by_key(|entry| std::cmp::Reverse(entry.1.usage_count)); println!("[Rust] Subterms with usage >= 2:"); for (hash, info, eff_size) in candidates { diff --git a/crates/ixon/src/diff.rs b/crates/ixon/src/diff.rs index bc162f10d..3e39b4d5e 100644 --- a/crates/ixon/src/diff.rs +++ b/crates/ixon/src/diff.rs @@ -2549,7 +2549,7 @@ mod tests { let index = Env::parse_lazy_index(&bytes).expect("lazy index"); let mut sizes: Vec<(usize, Address)> = index.consts.iter().map(|c| (c.len, c.addr.clone())).collect(); - sizes.sort_by(|a, b| b.0.cmp(&a.0)); + sizes.sort_by_key(|entry| std::cmp::Reverse(entry.0)); let total: usize = sizes.iter().map(|(l, _)| *l).sum(); println!("consts: {} total bytes: {}", sizes.len(), total); for (len, addr) in sizes.iter().take(top) { diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs index a194b0f94..67d3a95c5 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs @@ -75,7 +75,9 @@ fn addr_key(addr: &Address) -> Vec { fn packed_digest_key(addr: &Address) -> Vec { addr .as_bytes() - .chunks_exact(4) + .as_chunks::<4>() + .0 + .iter() .map(|w| { G::from_u32( u32::from(w[0]) diff --git a/crates/kernel/src/def_eq.rs b/crates/kernel/src/def_eq.rs index 4c06046eb..7d8f84d5f 100644 --- a/crates/kernel/src/def_eq.rs +++ b/crates/kernel/src/def_eq.rs @@ -87,8 +87,8 @@ impl TypeChecker<'_, M> { eprintln!( "[deq] {} {} ~ {}", self.fuel_used(), - &a.hash_key(), - &b.hash_key(), + a.hash_key(), + b.hash_key(), ); } if a.ptr_eq(b) { diff --git a/crates/kernel/src/inductive.rs b/crates/kernel/src/inductive.rs index 86ae079de..b5f0bc436 100644 --- a/crates/kernel/src/inductive.rs +++ b/crates/kernel/src/inductive.rs @@ -3868,13 +3868,7 @@ impl TypeChecker<'_, M> { }; let univ_offset = match rec_ids.first() { Some(rid) => match self.try_get_const(rid)? { - Some(KConst::Recr { lvls, .. }) => { - if lvls > ind_lvls { - 1u64 - } else { - 0u64 - } - }, + Some(KConst::Recr { lvls, .. }) if lvls > ind_lvls => 1u64, _ => 0, }, None => 0, diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs index 85ddbf8b6..1f8b7eba2 100644 --- a/crates/kernel/src/ingress.rs +++ b/crates/kernel/src/ingress.rs @@ -3875,17 +3875,7 @@ fn drop_ixon_env(ixon_env: IxonEnv, quiet: bool) { // set. Dropping them inline alongside the bookkeeping below is // negligible compared to the DashMap dropdance. // `..` covers the env's private fields. - let IxonEnv { - consts, - named, - blobs, - names, - comms, - anon_hints: _, - main: _, - assumptions: _, - .. - } = ixon_env; + let IxonEnv { consts, named, blobs, names, comms, .. } = ixon_env; let consts_len = consts.len(); let named_len = named.len(); let names_len = names.len(); diff --git a/crates/kernel/src/perf.rs b/crates/kernel/src/perf.rs index 8f1bcf888..033a77615 100644 --- a/crates/kernel/src/perf.rs +++ b/crates/kernel/src/perf.rs @@ -291,7 +291,7 @@ impl PerfCounters { let peak = self.peak_rec_fuel_used.load(Ordering::Relaxed); let total = self.total_rec_fuel_used.load(Ordering::Relaxed); let n = self.constants_checked.load(Ordering::Relaxed); - let avg = if n > 0 { total / n } else { 0 }; + let avg = total.checked_div(n).unwrap_or(0); writeln!(out, "[ix-perf] rec_fuel:")?; writeln!( out, diff --git a/crates/kernel/src/tc.rs b/crates/kernel/src/tc.rs index 3ba5fa617..5fd8348cd 100644 --- a/crates/kernel/src/tc.rs +++ b/crates/kernel/src/tc.rs @@ -917,13 +917,12 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { // Sharding profiler: flush the just-finished constant's heartbeats and // delta-unfold edges. `delta_targets` is always drained (even when // `cur_const` is unset) so producers never leak into the next constant. - if self.env.profile_sink.is_some() { + if let Some(sink) = &mut self.env.profile_sink { let producers = std::mem::take(&mut self.delta_targets); // Always drain the op counters (even when `cur_const` is unset) so they // never leak into the next constant, mirroring `delta_targets`. let ops = crate::profile::take_op_counts(); if let Some(addr) = self.cur_const.take() { - let sink = self.env.profile_sink.as_mut().unwrap(); sink.record(addr, used, producers, ops); } } diff --git a/crates/kernel/src/whnf.rs b/crates/kernel/src/whnf.rs index 8c628713f..38557a953 100644 --- a/crates/kernel/src/whnf.rs +++ b/crates/kernel/src/whnf.rs @@ -373,7 +373,7 @@ impl TypeChecker<'_, M> { // Step journal (see `IX_STEP_TRACE` in def_eq.rs); placed after the // quick exit to mirror the Lean kernel's `[whnf+]` site. if *IX_STEP_TRACE { - eprintln!("[whnf+] {} {}", self.fuel_used(), &e.hash_key()); + eprintln!("[whnf+] {} {}", self.fuel_used(), e.hash_key()); } // Context-aware cache: closed exprs use ptr only; open exprs include @@ -2010,11 +2010,11 @@ impl TypeChecker<'_, M> { Err(_) => return Ok(KSynthOutcome::Inconclusive), }; if *IX_KSYNTH_LOG { - eprintln!("[ksynth-attempt] {}", &ctor_app.hash_key()); + eprintln!("[ksynth-attempt] {}", ctor_app.hash_key()); } if !self.is_def_eq(&major_ty_w, &ctor_ty)? { if *IX_KSYNTH_LOG { - eprintln!("[ksynth-reject] {}", &ctor_app.hash_key()); + eprintln!("[ksynth-reject] {}", ctor_app.hash_key()); } // Cheap projection reduction can report a false negative that a later // full comparison resolves. Only a normal/full DefEq rejection can be diff --git a/flake.lock b/flake.lock index a5b07edb9..a18b189f8 100644 --- a/flake.lock +++ b/flake.lock @@ -33,17 +33,17 @@ ] }, "locked": { - "lastModified": 1787415051, - "narHash": "sha256-14ziKcXwmJ/ZihFpp3Cg6FLVPM8kCUVzR6t0iyae1hE=", + "lastModified": 1787430037, + "narHash": "sha256-0dLeEO55z4nHvSv8xb9BMoCZTbIc9IqVuId7z8oa4kA=", "owner": "argumentcomputer", "repo": "Blake3.lean", - "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9", + "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "type": "github" }, "original": { "owner": "argumentcomputer", "repo": "Blake3.lean", - "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9", + "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "type": "github" } }, diff --git a/flake.nix b/flake.nix index 546e2f6df..9254cf0bc 100644 --- a/flake.nix +++ b/flake.nix @@ -31,7 +31,7 @@ # Blake3 Rust bindings for Lean blake3-lean = { - url = "github:argumentcomputer/Blake3.lean/1b0fbd2bd78b2b873e14264037af8c8b1536b9e9"; + url = "github:argumentcomputer/Blake3.lean/e6e908bfd3af607ab44fb462fa2276a2c81addba"; # System packages, follows lean4-nix so we stay in sync inputs.lean4-nix.follows = "lean4-nix"; }; @@ -79,7 +79,7 @@ # Pins the Rust toolchain rustToolchain = fenix.packages.${system}.fromToolchainFile { file = ./rust-toolchain.toml; - sha256 = "sha256-sqSWJDUxc+zaz1nBWMAJKTAGBuGWP25GCftIOlCEAtA="; + sha256 = "sha256-P30Tm3O7vQAE725YtDCDHGjNrSsfZO4us11UwJGZSJo="; }; # Rust package diff --git a/lake-manifest.json b/lake-manifest.json index 9a93b385c..bcd9d4714 100644 --- a/lake-manifest.json +++ b/lake-manifest.json @@ -35,10 +35,10 @@ "type": "git", "subDir": null, "scope": "", - "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9", + "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "name": "Blake3", "manifestFile": "lake-manifest.json", - "inputRev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9", + "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "inherited": false, "configFile": "lakefile.lean"}, {"url": "https://github.com/argumentcomputer/LSpec", diff --git a/lakefile.lean b/lakefile.lean index ec304c5bf..cfbcb5fe1 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -13,7 +13,7 @@ BLAKE3 backend to Lean's native evaluator, and that dynlib gates every `IxTcVerify` module, so this pin must stay at or after the revision that introduced the target. -/ require Blake3 from git - "https://github.com/argumentcomputer/Blake3.lean" @ "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9" + "https://github.com/argumentcomputer/Blake3.lean" @ "e6e908bfd3af607ab44fb462fa2276a2c81addba" require Cli from git "https://github.com/leanprover/lean4-cli" @ "v4.33.0" diff --git a/rust-toolchain.toml b/rust-toolchain.toml index a5b578d83..23de05434 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,4 +1,4 @@ [toolchain] # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy. profile = "default" -channel = "1.92" +channel = "1.98" From f019632f49eead9e6f357378321a1c3d4f717da0 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 12:02:00 +0000 Subject: [PATCH 2/6] Provision Rust for fresh benchmark base builds PR benchmark runs execute trusted workflow YAML from the default branch while loading composite actions from the PR checkout. When Bencher data and binary caches are unavailable, the workflow checks out main under base/ and asks Lake to rebuild it without first installing the Rust channel pinned by that checkout. Teach the existing CPU provenance action to install the base checkout's validated Rust channel and profile immediately before an uncached base build. The step is a no-op when the toolchain is already available and leaves cached benchmark comparisons unchanged. --- .github/actions/log-cpu/action.yml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/.github/actions/log-cpu/action.yml b/.github/actions/log-cpu/action.yml index 69ae6dc05..b47cea486 100644 --- a/.github/actions/log-cpu/action.yml +++ b/.github/actions/log-cpu/action.yml @@ -30,6 +30,32 @@ inputs: runs: using: composite steps: + # PR benchmarks execute trusted workflow YAML from the default branch but + # load this action from the PR checkout. Ensure a freshly checked-out base + # has its pinned Rust toolchain before Lake invokes Cargo. + - name: Bootstrap base Rust toolchain + if: inputs.label == 'Base benchmark binary build CPU' + shell: bash + run: | + set -euo pipefail + + toolchain_file=base/rust-toolchain.toml + [ -f "$toolchain_file" ] || { echo "::error::$toolchain_file is missing"; exit 1; } + channel=$(awk -F '"' '/^[[:space:]]*channel[[:space:]]*=/ { print $2; exit }' "$toolchain_file") + profile=$(awk -F '"' '/^[[:space:]]*profile[[:space:]]*=/ { print $2; exit }' "$toolchain_file") + if [[ ! "$channel" =~ ^[A-Za-z0-9._+-]+$ ]]; then + echo "::error::$toolchain_file has an invalid Rust channel" + exit 1 + fi + case "${profile:-default}" in + minimal|default|complete) ;; + *) echo "::error::$toolchain_file has an invalid Rust profile"; exit 1 ;; + esac + + rustup run "$channel" rustc --version >/dev/null 2>&1 && exit 0 + echo "Installing Rust $channel (${profile:-default} profile) for the fresh base build" + rustup toolchain install "$channel" --profile "${profile:-default}" --no-self-update + - shell: bash env: CPU_LABEL: ${{ inputs.label }} From 32a517c386cae82607fcfc1d9b3e235f9051a454 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 14:05:07 +0000 Subject: [PATCH 3/6] Verify native Plonky3 multiproofs recursively Consume the Plonky3 0.6 batch-opening layout directly in Aiur instead of expanding every pruned Merkle frontier into one authentication path per FRI query. Sample all query indices from the unchanged transcript, sort and deduplicate them with an O(q log q) merge sort, authenticate each input and commit-phase commitment once, then retain the existing per-query reduced-opening and FRI arithmetic. Bind every frontier to transcript-derived indices, consume boundary digests in Plonky3's level/parent/child order, reject trailing frontier elements and inconsistent duplicate leaves, and assert all native opening dimensions and sibling counts. Explicitly constrain the digest-bound protocol specialization to cap height 0, binary FRI, and a constant final polynomial. Move memo_u32_less_than into IxVM Core so both substitution and multiproof sorting share its constrained rows. Strengthen the recursive negative test to mutate a structurally valid stage-1 commitment. Regenerate both checked-in Aiur Rust executors and retain interpreter/codegen query-count parity. On Vector.extract_append q50, recursive-verifier FFT cost falls from 204.073B to 201.166B. CPU outer proving improves from 50.09s to 45.03s and the full CPU pipeline from 90.64s to 82.90s. GPU outer proving improves from 15.85s to 13.72s and the full GPU pipeline from 28.86s to 26.69s. The outer proof grows from 3.92 MB to 4.17 MB. Validated with the MultiStark primitive suite, recursive honest/tamper/parity tests, codegen --check, release workspace clippy, release CUDA clippy, rustfmt, and diff checks. --- Ix/IxVM/Core.lean | 10 + Ix/IxVM/Kernel/Subst.lean | 8 - Ix/MultiStark/Deserialize.lean | 93 +- Ix/MultiStark/Pcs.lean | 268 +- Ix/MultiStark/Verifier.lean | 12 +- Tests/MultiStark.lean | 12 +- crates/aiur/src/synthesis.rs | 15 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 31411 +++++++++--------- crates/ixvm-codegen/src/aiur_multi_stark.rs | 9408 +++--- 9 files changed, 21042 insertions(+), 20195 deletions(-) diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean index a32e74d71..619ba613e 100644 --- a/Ix/IxVM/Core.lean +++ b/Ix/IxVM/Core.lean @@ -18,6 +18,16 @@ def core := ⟦ None } + -- Memoized u32 comparison for hot structural and frontier walks. Aiur + -- memoizes function calls automatically, so keeping the decomposition in + -- this shared helper avoids charging the wide intrinsic layout repeatedly; + -- recurring `(a, b)` pairs share one constrained helper row. This belongs + -- in Core because both the IxVM substitution circuits and the recursive + -- multi-STARK verifier rely on the same optimization. + fn memo_u32_less_than(a: G, b: G) -> G { + u32_less_than(a, b) + } + -- Interned 32-element address (blake3 content hash). -- -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean index 5250e5815..1a1b8bef9 100644 --- a/Ix/IxVM/Kernel/Subst.lean +++ b/Ix/IxVM/Kernel/Subst.lean @@ -90,14 +90,6 @@ def subst := ⟦ } } - -- Memoized structural comparison used by substitution fast paths. Keeping - -- the u32 decomposition in this helper avoids charging its wide intrinsic - -- layout on every row of a hot substitution circuit; repeated `(depth,lbr)` - -- pairs share one constrained helper row. - fn memo_u32_less_than(a: G, b: G) -> G { - u32_less_than(a, b) - } - -- ============================================================================ -- has_bvar_in_range -- diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean index 96fcb9cbf..2a808d36d 100644 --- a/Ix/MultiStark/Deserialize.lean +++ b/Ix/MultiStark/Deserialize.lean @@ -79,34 +79,37 @@ def deserialize := ⟦ Mk(MerkleCap, MerkleCap, MerkleCap) } - -- `BatchOpening`: per-round input opening of a FRI query. - -- opened_values : Vec> (one row of base-field values per matrix) - -- opening_proof : Vec (Merkle authentication path) - enum BatchOpening { - Mk(List‹List‹U64››, List‹DigestP›) + -- One input commitment opened at all query indices with a shared pruned + -- Merkle frontier. `opened_values[q][m]` is query q's row of matrix m. + enum BatchMultiOpening { + Mk(List‹List‹List‹U64›››, List‹DigestP›) } -- `CommitPhaseProofStep`: one folding step of a FRI query. -- log_arity : u8 -- sibling_values : Vec (arity - 1 siblings) -- opening_proof : Vec - enum CommitPhaseProofStep { - Mk(U8, List‹Ext›, List‹DigestP›) + enum CommitPhaseMultiStep { + Mk(U8, List‹List‹Ext››, List‹DigestP›) } - -- `QueryProof>>`. - enum QueryProof { - Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) - } + -- Per-query views derived in-circuit from the native batch openings. They + -- retain the existing FRI arithmetic organization; authentication is done + -- once per native multiproof before that arithmetic runs. + enum BatchOpening { Mk(List‹List‹U64››) } + enum CommitPhaseProofStep { Mk(U8, List‹Ext›) } + enum QueryProof { Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) } -- `PcsProof = FriProof`. -- commit_phase_commits : Vec -- commit_pow_witnesses : Vec - -- query_proofs : Vec + -- input_openings : Vec + -- commit_phase_openings: Vec -- final_poly : Vec -- query_pow_witness : Val enum FriProof { - Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64) + Mk(List‹MerkleCap›, List‹U64›, List‹BatchMultiOpening›, + List‹CommitPhaseMultiStep›, List‹Ext›, U64) } -- `Option` for `preprocessed_opened_values`. A dedicated @@ -301,6 +304,20 @@ def deserialize := ⟦ } } + fn read_u64_vec_vec_vec(i: G) -> (List‹List‹List‹U64›››, G) { + let (n, j) = read_count_at(i); + read_u64_vec_vec_vec_n(j, n) + } + fn read_u64_vec_vec_vec_n(i: G, n: G) -> (List‹List‹List‹U64›››, G) { + match n { + 0 => (store(ListNode.Nil), i), + _ => + let (x, j) = @read_u64_vec_vec(i); + let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1); + (store(ListNode.Cons(x, rest)), j2), + } + } + -- `OpenedRound = Vec>>`, built bottom-up from `read_ext_vec`. fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) { let (n, j) = read_count_at(i); @@ -358,16 +375,16 @@ def deserialize := ⟦ (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2) } - fn read_batch_opening(i: G) -> (BatchOpening, G) { - let (opened_values, j0) = @read_u64_vec_vec(i); + fn read_batch_opening(i: G) -> (BatchMultiOpening, G) { + let (opened_values, j0) = @read_u64_vec_vec_vec(i); let (opening_proof, j1) = read_digest_vec_at(j0); - (BatchOpening.Mk(opened_values, opening_proof), j1) + (BatchMultiOpening.Mk(opened_values, opening_proof), j1) } - fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) { + fn read_batch_opening_vec(i: G) -> (List‹BatchMultiOpening›, G) { let (n, j) = read_count_at(i); read_batch_opening_vec_n(j, n) } - fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) { + fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchMultiOpening›, G) { match n { 0 => (store(ListNode.Nil), i), _ => @@ -377,17 +394,17 @@ def deserialize := ⟦ } } - fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) { + fn read_commit_phase_step(i: G) -> (CommitPhaseMultiStep, G) { let (log_arity, j0) = #read_u8_at(i); - let (sibling_values, j1) = read_ext_vec(j0); + let (sibling_values, j1) = @read_ext_vec_vec(j0); let (opening_proof, j2) = read_digest_vec_at(j1); - (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2) + (CommitPhaseMultiStep.Mk(log_arity, sibling_values, opening_proof), j2) } - fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) { + fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseMultiStep›, G) { let (n, j) = read_count_at(i); read_commit_phase_step_vec_n(j, n) } - fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) { + fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseMultiStep›, G) { match n { 0 => (store(ListNode.Nil), i), _ => @@ -397,33 +414,15 @@ def deserialize := ⟦ } } - fn read_query_proof(i: G) -> (QueryProof, G) { - let (input_proof, j0) = @read_batch_opening_vec(i); - let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0); - (QueryProof.Mk(input_proof, commit_phase_openings), j1) - } - fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) { - let (n, j) = read_count_at(i); - read_query_proof_vec_n(j, n) - } - fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_query_proof(i); - let (rest, j2) = read_query_proof_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - fn read_fri_proof(i: G) -> (FriProof, G) { let (commit_phase_commits, j0) = @read_merkle_cap_vec(i); let (commit_pow_witnesses, j1) = read_u64_vec(j0); - let (query_proofs, j2) = @read_query_proof_vec(j1); - let (final_poly, j3) = read_ext_vec(j2); - let (query_pow_witness, j4) = #read_u64_at(j3); - (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs, - final_poly, query_pow_witness), j4) + let (input_openings, j2) = @read_batch_opening_vec(j1); + let (commit_phase_openings, j3) = @read_commit_phase_step_vec(j2); + let (final_poly, j4) = read_ext_vec(j3); + let (query_pow_witness, j5) = #read_u64_at(j4); + (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, input_openings, + commit_phase_openings, final_poly, query_pow_witness), j5) } -- The activation bitmap: `Vec` on the wire (u64 count, then one diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean index 82a147c20..9ac8b4c65 100644 --- a/Ix/MultiStark/Pcs.lean +++ b/Ix/MultiStark/Pcs.lean @@ -515,6 +515,129 @@ def pcs := ⟦ eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root)) } + -- A node in the sorted multiproof frontier. Rows are retained from the + -- lead query so shorter matrices can be injected at their native height. + enum FrontierNode { Mk(G, List‹G›, List‹List‹U64››, DigestP) } + + fn frontier_merge(xs: List‹FrontierNode›, ys: List‹FrontierNode›) -> List‹FrontierNode› { + match load(xs) { + ListNode.Nil => ys, + ListNode.Cons(x, xrest) => match load(ys) { + ListNode.Nil => xs, + ListNode.Cons(y, yrest) => + let FrontierNode.Mk(xi, _xb, _xr, xd) = x; + let FrontierNode.Mk(yi, _yb, _yr, yd) = y; + match memo_u32_less_than(xi, yi) { + 1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))), + _ => match eq_zero(xi - yi) { + 1 => + -- Duplicate transcript queries must open the same leaf. A + -- direct pointer assertion is sound here: only equality is + -- accepted; non-canonical equal digests can at worst reject. + assert_eq!(ptr_val(xd), ptr_val(yd)); + store(ListNode.Cons(x, frontier_merge(xrest, yrest))), + _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))), + }, + }, + }, + } + } + + -- Deal alternating elements into two half-sized lists. Their internal order + -- is irrelevant because each half is recursively sorted before merging. + fn frontier_split(xs: List‹FrontierNode›) -> (List‹FrontierNode›, List‹FrontierNode›) { + match load(xs) { + ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)), + ListNode.Cons(x, rest) => match load(rest) { + ListNode.Nil => (store(ListNode.Cons(x, store(ListNode.Nil))), store(ListNode.Nil)), + ListNode.Cons(y, tail) => + let (left, right) = frontier_split(tail); + (store(ListNode.Cons(x, left)), store(ListNode.Cons(y, right))), + }, + } + } + + fn frontier_sort(xs: List‹FrontierNode›) -> List‹FrontierNode› { + match load(xs) { + ListNode.Nil => xs, + ListNode.Cons(_x, rest) => match load(rest) { + ListNode.Nil => xs, + ListNode.Cons(_y, _tail) => + let (left, right) = frontier_split(xs); + frontier_merge(frontier_sort(left), frontier_sort(right)), + }, + } + } + + fn frontier_leaves(indices: List‹List‹G››, rows: List‹List‹List‹U64›››, + lhs: List‹G›, log_max: G) -> List‹FrontierNode› { + match load(indices) { + ListNode.Nil => + assert_eq!(list_length(rows), 0); + store(ListNode.Nil), + ListNode.Cons(bits, irest) => + let &ListNode.Cons(r, rrest) = rows; + let d = leaf_hash_at(r, lhs, log_max); + store(ListNode.Cons(FrontierNode.Mk(bits_to_num(bits), bits, r, d), + frontier_leaves(irest, rrest, lhs, log_max))), + } + } + + -- Fold one binary frontier level. Boundary siblings are consumed in the + -- exact ascending-parent/ascending-child order used by Plonky3 pruning. + fn frontier_level(nodes: List‹FrontierNode›, proof: List‹DigestP›, + lhs: List‹G›, next_lh: G) -> (List‹FrontierNode›, List‹DigestP›) { + match load(nodes) { + ListNode.Nil => (store(ListNode.Nil), proof), + ListNode.Cons(a, rest) => + let FrontierNode.Mk(ai, abits, ar, ad) = a; + let &ListNode.Cons(abit, aparent_bits) = abits; + let aparent = bits_to_num(aparent_bits); + match load(rest) { + ListNode.Cons(b, brest) => + let FrontierNode.Mk(bi, bbits, _br, bd) = b; + let &ListNode.Cons(_bbit, bparent_bits) = bbits; + match eq_zero(aparent - bits_to_num(bparent_bits)) { + 1 => + let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd)); + let (tail, p2) = frontier_level(brest, proof, lhs, next_lh); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), + _ => + let &ListNode.Cons(sib, prest) = proof; + let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); + let (tail, p2) = frontier_level(rest, prest, lhs, next_lh); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), + }, + ListNode.Nil => + let &ListNode.Cons(sib, prest) = proof; + let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), store(ListNode.Nil))), prest), + }, + } + } + + fn frontier_fold(nodes: List‹FrontierNode›, proof: List‹DigestP›, + lhs: List‹G›, levels: G) -> (List‹FrontierNode›, List‹DigestP›) { + match levels { + 0 => (nodes, proof), + _ => + let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1); + frontier_fold(next, p2, lhs, levels - 1), + } + } + + fn mmcs_verify_multi(cap: MerkleCap, rows: List‹List‹List‹U64›››, + lhs: List‹G›, indices: List‹List‹G››, proof: List‹DigestP›, log_max: G) -> G { + assert_eq!(eq_zero(list_length(rows) - list_length(indices)), 1); + let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max)); + let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max); + assert_eq!(list_length(rest), 0); + let &ListNode.Cons(root, no_more) = roots; + assert_eq!(list_length(no_more), 0); + let FrontierNode.Mk(capidx, _bits, _rows, digest) = root; + eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest)) + } + -- ========================================================================== -- FRI fold step (`TwoAdicFriFolding::fold_row`, arity-2 case). -- @@ -826,7 +949,7 @@ def pcs := ⟦ match prep_opt { PreprocessedOpt.NoPreprocessed => buckets, PreprocessedOpt.SomePreprocessed(prep_round) => - let BatchOpening.Mk(rows_p, proof_p) = list_lookup(input_proof, 3); + let BatchOpening.Mk(rows_p) = list_lookup(input_proof, 3); -- one opened base row per preprocessed matrix (BatchOpenedValuesCountMismatch) assert_eq!(eq_zero(list_length(rows_p) - list_length(prep_round)), 1); -- The preprocessed tree's max height is over the PREP circuits only, so @@ -836,8 +959,6 @@ def pcs := ⟦ -- of the LSB-first bit list) and verify against the batch's own height. let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); let log_pmax = heights_max(prep_heights); - assert_eq!(mmcs_verify(prep_commit, rows_p, prep_heights, - list_drop(idxbits, log_gmax - log_pmax), proof_p, log_pmax), 1); open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees, prep_indices, zeta, rows_p, prep_round, alpha), } @@ -904,7 +1025,7 @@ def pcs := ⟦ } fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›, openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G, - ro_rest: List‹Bucket›, log_final: G) -> Ext { + ro_rest: List‹Bucket›, log_final: G) -> (Ext, List‹List‹U64››) { match load(openings) { ListNode.Nil => -- must have folded down to exactly the final domain size, and every @@ -912,22 +1033,20 @@ def pcs := ⟦ -- UnconsumedReducedOpenings). assert_eq!(eq_zero(log_cur - log_final), 1); assert_eq!(list_length(ro_rest), 0); - folded, + (folded, store(ListNode.Nil)), ListNode.Cons(op, op_rest) => let &ListNode.Cons(beta, beta_rest) = betas; let &ListNode.Cons(comm, comm_rest) = comms; - let CommitPhaseProofStep.Mk(_la, sibs, oproof) = op; + let CommitPhaseProofStep.Mk(_la, sibs) = op; -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch). assert_eq!(list_length(sibs), 1); let &ListNode.Cons(ibit, idrest) = domidx; -- index_in_group = LSB let log_folded = log_cur - 1; let (e0, e1) = @recon_evals(ibit, folded, list_lookup(sibs, 0)); - -- authenticate the sibling pair against this round's commitment - assert_eq!(mmcs_verify(comm, store(ListNode.Cons(@flatten2(e0, e1), store(ListNode.Nil))), - store(ListNode.Cons(log_folded, store(ListNode.Nil))), idrest, oproof, log_folded), 1); let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1); let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest); - verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final), + let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final); + (result, store(ListNode.Cons(@flatten2(e0, e1), rows))), } } @@ -941,7 +1060,7 @@ def pcs := ⟦ prep_commit: MerkleCap, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> G { + num_rounds: G) -> List‹List‹U64›› { let QueryProof.Mk(input_proof, commit_phase_openings) = qp; -- one commit-phase opening per round (QueryCommitPhaseOpeningsCountMismatch), -- one input batch per commitment (InputProofBatchCountMismatch). @@ -951,19 +1070,16 @@ def pcs := ⟦ -- one heights list for all three stage batches (memoized anyway; this -- also drops two call-output columns per proof) let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); - let BatchOpening.Mk(rows_s1, proof_s1) = list_lookup(input_proof, 0); + let BatchOpening.Mk(rows_s1) = list_lookup(input_proof, 0); assert_eq!(eq_zero(list_length(rows_s1) - num_circuits), 1); - assert_eq!(mmcs_verify(s1c, rows_s1, hall, idxbits, proof_s1, log_gmax), 1); let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha); - let BatchOpening.Mk(rows_s2, proof_s2) = list_lookup(input_proof, 1); + let BatchOpening.Mk(rows_s2) = list_lookup(input_proof, 1); assert_eq!(eq_zero(list_length(rows_s2) - num_circuits), 1); - assert_eq!(mmcs_verify(s2c, rows_s2, hall, idxbits, proof_s2, log_gmax), 1); let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha); - let BatchOpening.Mk(rows_q, proof_q) = list_lookup(input_proof, 2); + let BatchOpening.Mk(rows_q) = list_lookup(input_proof, 2); -- one wide quotient matrix per circuit, on the trace domain, so the -- quotient batch's heights are the same per-circuit heights as the stages assert_eq!(eq_zero(list_length(rows_q) - num_circuits), 1); - assert_eq!(mmcs_verify(qc, rows_q, hall, idxbits, proof_q, log_gmax), 1); let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha); let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha); -- a height-`log_blowup` (constant-poly) reduced opening must be zero @@ -973,10 +1089,10 @@ def pcs := ⟦ let &ListNode.Cons(b0, ro_rest) = buckets; let Bucket.Mk(h0, _ap0, folded_start) = b0; assert_eq!(eq_zero(h0 - log_gmax), 1); - let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); + let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); -- final check: with log_final_poly_len = 0, eval = final_poly[0] assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1); - 1 + fri_rows } -- Loop over all `num_queries` query proofs, sampling one index per query @@ -987,17 +1103,106 @@ def pcs := ⟦ prep_commit: MerkleCap, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> G { + num_rounds: G) -> List‹List‹List‹U64››› { match load(query_proofs) { - ListNode.Nil => 1, + ListNode.Nil => store(ListNode.Nil), ListNode.Cons(qp, rest) => let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax); - let _q = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, + let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); - query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, + store(ListNode.Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, - log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds), + log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds))), + } + } + + fn sample_query_indices(input: ByteStream, output: ByteStream, n: G, + log_gmax: G) -> List‹List‹G›› { + match n { + 0 => store(ListNode.Nil), + _ => + let (bits, input2, output2) = ch_sample_bits(input, output, log_gmax); + store(ListNode.Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax))), + } + } + + fn batch_views_at(bs: List‹BatchMultiOpening›, q: G) -> List‹BatchOpening› { + match load(bs) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(b, rest) => + let BatchMultiOpening.Mk(rows, _proof) = b; + store(ListNode.Cons(BatchOpening.Mk(list_lookup(rows, q)), batch_views_at(rest, q))), + } + } + fn step_views_at(ss: List‹CommitPhaseMultiStep›, q: G) -> List‹CommitPhaseProofStep› { + match load(ss) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(s, rest) => + let CommitPhaseMultiStep.Mk(la, sibs, _proof) = s; + store(ListNode.Cons(CommitPhaseProofStep.Mk(la, list_lookup(sibs, q)), step_views_at(rest, q))), + } + } + fn query_views(bs: List‹BatchMultiOpening›, ss: List‹CommitPhaseMultiStep›, + q: G, n: G) -> List‹QueryProof› { + match n { + 0 => store(ListNode.Nil), + _ => store(ListNode.Cons(QueryProof.Mk(batch_views_at(bs, q), step_views_at(ss, q)), + query_views(bs, ss, q + 1, n - 1))), + } + } + + fn verify_input_multi(bs: List‹BatchMultiOpening›, indices: List‹List‹G››, + s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap, + prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, + num_circuits: G, log_blowup: G, log_gmax: G) -> G { + let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); + let BatchMultiOpening.Mk(s1rows, s1proof) = list_lookup(bs, 0); + let BatchMultiOpening.Mk(s2rows, s2proof) = list_lookup(bs, 1); + let BatchMultiOpening.Mk(qrows, qproof) = list_lookup(bs, 2); + assert_eq!(mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1); + assert_eq!(mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1); + assert_eq!(mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1); + match prep_opt { + PreprocessedOpt.NoPreprocessed => 1, + PreprocessedOpt.SomePreprocessed(_round) => + let BatchMultiOpening.Mk(prows, pproof) = list_lookup(bs, 3); + let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); + let lp = heights_max(ph); + let pindices = drop_index_bits(indices, log_gmax - lp); + mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp), + } + } + fn drop_index_bits(indices: List‹List‹G››, n: G) -> List‹List‹G›› { + match load(indices) { + ListNode.Nil => indices, + ListNode.Cons(bits, rest) => + store(ListNode.Cons(list_drop(bits, n), drop_index_bits(rest, n))), + } + } + fn rows_at_round(rows: List‹List‹List‹U64›››, r: G) -> List‹List‹List‹U64››› { + match load(rows) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(qrows, rest) => + store(ListNode.Cons(store(ListNode.Cons(list_lookup(qrows, r), store(ListNode.Nil))), + rows_at_round(rest, r))), + } + } + fn verify_commit_multi(steps: List‹CommitPhaseMultiStep›, comms: List‹MerkleCap›, + all_rows: List‹List‹List‹U64›››, indices: List‹List‹G››, r: G, + log_cur: G) -> G { + match load(steps) { + ListNode.Nil => eq_zero(list_length(comms)), + ListNode.Cons(s, srest) => + let &ListNode.Cons(c, crest) = comms; + let CommitPhaseMultiStep.Mk(la, sibs, proof) = s; + assert_eq!(to_field(la), 1); + assert_eq!(list_length(sibs), list_length(indices)); + let next_indices = drop_index_bits(indices, 1); + let lh = log_cur - 1; + assert_eq!(mmcs_verify_multi(c, rows_at_round(all_rows, r), + store(ListNode.Cons(lh, store(ListNode.Nil))), next_indices, proof, lh), 1); + verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh), } } @@ -1010,12 +1215,14 @@ def pcs := ⟦ prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G, query_pow_bits: G) -> G { - let FriProof.Mk(commit_phase_commits, pw, query_proofs, final_poly, qpw) = opening; + let FriProof.Mk(commit_phase_commits, pw, input_openings, commit_phase_openings, + final_poly, qpw) = opening; let num_rounds = list_length(commit_phase_commits); -- FRI shape: one PoW witness per round, num_queries query proofs, and (since -- log_final_poly_len = 0) a single final-poly coefficient. assert_eq!(eq_zero(list_length(pw) - num_rounds), 1); - assert_eq!(eq_zero(list_length(query_proofs) - num_queries), 1); + assert_eq!(list_length(input_openings), 3 + prep_count(prep_opt)); + assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1); assert_eq!(list_length(final_poly), 1); -- challenger continuation: observe all opened values (coms_to_verify -- order), built as one front-to-back suffix + a single concat (the input @@ -1041,9 +1248,14 @@ def pcs := ⟦ -- max height so `two_adic_gen`'s squaring chain (bits ≤ 32) and the -- 32-bit query-index decomposition stay within range. assert_eq!(u32_less_than(log_gmax, 33), 1); - query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, + let indices = sample_query_indices(input, output, num_queries, log_gmax); + assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc, + prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1); + let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries); + let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, - num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds) + num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); + verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax) } ⟧ diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean index b11b6a79e..5e72fd32c 100644 --- a/Ix/MultiStark/Verifier.lean +++ b/Ix/MultiStark/Verifier.lean @@ -871,9 +871,17 @@ def verifier := ⟦ -- `query_pow_bits`) all come from the verifying key, which the public -- statement binds through `system_digest` — no separate public inputs. let Sys.Mk(params, tlimbs, circuits, commit, prep_indices) = sys; - let SysParams.Mk(log_blowup, _cap_height, _log_final_poly_len, - _max_log_arity, num_queries, commit_pow_bits, + let SysParams.Mk(log_blowup, cap_height, log_final_poly_len, + max_log_arity, num_queries, commit_pow_bits, query_pow_bits) = params; + -- This recursive verifier is deliberately specialized to root caps, + -- binary FRI folds, and a constant final polynomial. These parameters are + -- digest-bound but still prover-visible inputs to this circuit, so reject + -- unsupported systems explicitly instead of silently applying the wrong + -- Merkle geometry or folding semantics. + assert_eq!(cap_height, 0); + assert_eq!(log_final_poly_len, 0); + assert_eq!(max_log_arity, 1); let Proof.Mk(active, commitments, accs, log_degrees, opening, q_opened, prep_opt, stage1, stage2) = proof; -- Sparse activation: the bitmap covers the canonical circuit set; diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 4e36fa670..b62c08414 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -189,10 +189,16 @@ def endToEndSuite : IO UInt32 := do | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1 -- ── negative-test inputs ──────────────────────────────────────────────────── - -- Tampered proof advice: flip byte 0 (the first stage_1-commitment limb) so the - -- replayed Fiat-Shamir transcript diverges from the one the proof was made under. + -- Tampered proof advice: locate the first stage-1 commitment byte after the + -- native proof's `Vec` activation bitmap and cap-length prefix. This + -- keeps the proof structurally parseable while forcing Fiat-Shamir and the + -- Merkle checks away from the proof that was actually produced. + let activeLen := (List.range 8).foldl (fun n i => + n ||| (proofBytes.data[i]!.toUInt64 <<< (i * 8).toUInt64)) 0 + let firstCommitByte := 8 + activeLen.toNat + 8 let badProofBytes := - proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256)) + proofBytes.set! firstCommitByte + (UInt8.ofNat ((proofBytes.data[firstCommitByte]!.toNat + 1) % 256)) -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the -- composition/quotient identity no longer holds even though the binding passes. diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 70e598184..1bfec2b9d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -444,20 +444,17 @@ impl AiurSystem { self.system.verify(claim, proof) } - /// Re-encode a verified proof into the per-query authentication-path - /// transport consumed by the in-circuit recursive verifier. + /// Verify and serialize the native Plonky3 multiproof for the in-circuit + /// recursive verifier. pub fn proof_to_advice_bytes( &self, claim: &[G], proof: &AiurProof, ) -> Result, multi_stark::advice::AdviceError> { - multi_stark::advice::proof_to_advice_bytes( - &self.system, - self.commitment_parameters, - self.fri_parameters, - &[claim], - proof, - ) + self.verify(claim, proof).map_err(|e| { + multi_stark::advice::AdviceError::Verification(format!("{e:?}")) + })?; + proof.to_bytes().map_err(multi_stark::advice::AdviceError::Encode) } } diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index b413a2dbd..f2e10bc6b 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -25,6 +25,25 @@ fn aiur_fn_0( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __ret: [G; OUT_0] = [__v_2]; + if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_1: usize = 2; +const IN_1: usize = 2; +const OUT_1: usize = 1; +fn aiur_fn_1( + inp: [G; IN_1], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -266,61 +285,61 @@ fn aiur_fn_0( match __v_226.as_canonical_u64() { 0u64 => { let __v_227: G = G::from_u64(1); - let __ret: [G; OUT_0] = [__v_227]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_227]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_227]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_227]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_214: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_214]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_214]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_177: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_177]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_177]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_140: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_140]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_140]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_103: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_103]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_103]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_1: usize = 2; -const IN_1: usize = 2; -const OUT_1: usize = 1; -fn aiur_fn_1( - inp: [G; IN_1], +const INPUT_SIZE_2: usize = 2; +const IN_2: usize = 2; +const OUT_2: usize = 1; +fn aiur_fn_2( + inp: [G; IN_2], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_1], ExecError> { +) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -393,31 +412,31 @@ fn aiur_fn_1( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __ret: [G; OUT_1] = [__v_67]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_67]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_67]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_67]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_2: usize = 3; -const IN_2: usize = 3; -const OUT_2: usize = 1; -fn aiur_fn_2( - inp: [G; IN_2], +const INPUT_SIZE_3: usize = 3; +const IN_3: usize = 3; +const OUT_3: usize = 1; +fn aiur_fn_3( + inp: [G; IN_3], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_2], ExecError> { +) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -427,8 +446,8 @@ fn aiur_fn_2( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_2] = [__v_5]; - if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_3] = [__v_5]; + if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -436,29 +455,29 @@ fn aiur_fn_2( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_2] = [__v_10]; - if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_3] = [__v_10]; + if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_3: usize = 8; -const IN_3: usize = 8; -const OUT_3: usize = 1; -fn aiur_fn_3( - inp: [G; IN_3], +const INPUT_SIZE_4: usize = 8; +const IN_4: usize = 8; +const OUT_4: usize = 1; +fn aiur_fn_4( + inp: [G; IN_4], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_3], ExecError> { +) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -483,14 +502,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -499,14 +518,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -519,14 +538,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -535,14 +554,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -559,14 +578,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -575,14 +594,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -595,14 +614,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -611,14 +630,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -639,14 +658,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -655,14 +674,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -675,14 +694,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -691,14 +710,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -715,14 +734,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -731,14 +750,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -751,14 +770,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -767,14 +786,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -799,14 +818,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -815,14 +834,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -835,14 +854,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -851,14 +870,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -875,14 +894,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -891,14 +910,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -911,14 +930,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -927,14 +946,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -955,14 +974,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -971,14 +990,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -991,14 +1010,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1007,14 +1026,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1031,14 +1050,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1047,14 +1066,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1067,14 +1086,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1083,14 +1102,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1119,14 +1138,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1135,14 +1154,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1155,14 +1174,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1171,14 +1190,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1195,14 +1214,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1211,14 +1230,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1231,14 +1250,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1247,14 +1266,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1275,14 +1294,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1291,14 +1310,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1311,14 +1330,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1327,14 +1346,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1351,14 +1370,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1367,14 +1386,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1387,14 +1406,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1403,14 +1422,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1435,14 +1454,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1451,14 +1470,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1471,14 +1490,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1487,14 +1506,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1511,14 +1530,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1527,14 +1546,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1547,14 +1566,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1563,14 +1582,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1591,14 +1610,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1607,14 +1626,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1627,14 +1646,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1643,14 +1662,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1667,14 +1686,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1683,14 +1702,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1703,14 +1722,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1719,14 +1738,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -1745,15 +1764,15 @@ fn aiur_fn_3( }) } -const INPUT_SIZE_4: usize = 8; -const IN_4: usize = 8; -const OUT_4: usize = 1; -fn aiur_fn_4( - inp: [G; IN_4], +const INPUT_SIZE_5: usize = 8; +const IN_5: usize = 8; +const OUT_5: usize = 1; +fn aiur_fn_5( + inp: [G; IN_5], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_4], ExecError> { +) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1780,85 +1799,85 @@ fn aiur_fn_4( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_5: usize = 8; -const IN_5: usize = 8; -const OUT_5: usize = 4; -fn aiur_fn_5( - inp: [G; IN_5], +const INPUT_SIZE_6: usize = 8; +const IN_6: usize = 8; +const OUT_6: usize = 4; +fn aiur_fn_6( + inp: [G; IN_6], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_5], ExecError> { +) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1881,21 +1900,21 @@ fn aiur_fn_5( if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_6: usize = 12; -const IN_6: usize = 12; -const OUT_6: usize = 4; -fn aiur_fn_6( - inp: [G; IN_6], +const INPUT_SIZE_7: usize = 12; +const IN_7: usize = 12; +const OUT_7: usize = 4; +fn aiur_fn_7( + inp: [G; IN_7], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_6], ExecError> { +) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1928,21 +1947,21 @@ fn aiur_fn_6( if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_7] = [__v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_7: usize = 8; -const IN_7: usize = 8; -const OUT_7: usize = 4; -fn aiur_fn_7( - inp: [G; IN_7], +const INPUT_SIZE_8: usize = 8; +const IN_8: usize = 8; +const OUT_8: usize = 4; +fn aiur_fn_8( + inp: [G; IN_8], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_7], ExecError> { +) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1956,27 +1975,7 @@ fn aiur_fn_7( let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; - let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_8: usize = 4; -const IN_8: usize = 4; -const OUT_8: usize = 4; -fn aiur_fn_8( - inp: [G; IN_8], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_8], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; + let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11]; if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -1996,14 +1995,14 @@ fn aiur_fn_9( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; + let __ret: [G; OUT_9] = [__v_2, __v_3, __v_0, __v_1]; if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_10: usize = 8; -const IN_10: usize = 8; +const INPUT_SIZE_10: usize = 4; +const IN_10: usize = 4; const OUT_10: usize = 4; fn aiur_fn_10( inp: [G; IN_10], @@ -2011,6 +2010,26 @@ fn aiur_fn_10( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __ret: [G; OUT_10] = [__v_1, __v_2, __v_3, __v_0]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_11: usize = 8; +const IN_11: usize = 8; +const OUT_11: usize = 4; +fn aiur_fn_11( + inp: [G; IN_11], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2036,21 +2055,21 @@ fn aiur_fn_10( let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); - let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_11: usize = 8; -const IN_11: usize = 8; -const OUT_11: usize = 4; -fn aiur_fn_11( - inp: [G; IN_11], +const INPUT_SIZE_12: usize = 8; +const IN_12: usize = 8; +const OUT_12: usize = 4; +fn aiur_fn_12( + inp: [G; IN_12], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_11], ExecError> { +) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2076,21 +2095,21 @@ fn aiur_fn_11( let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); - let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_12: usize = 16; -const IN_12: usize = 16; -const OUT_12: usize = 1; -fn aiur_fn_12( - inp: [G; IN_12], +const INPUT_SIZE_13: usize = 16; +const IN_13: usize = 16; +const OUT_13: usize = 1; +fn aiur_fn_13( + inp: [G; IN_13], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_12], ExecError> { +) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2133,85 +2152,85 @@ fn aiur_fn_12( match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_13: usize = 16; -const IN_13: usize = 16; -const OUT_13: usize = 9; -fn aiur_fn_13( - inp: [G; IN_13], +const INPUT_SIZE_14: usize = 16; +const IN_14: usize = 16; +const OUT_14: usize = 9; +fn aiur_fn_14( + inp: [G; IN_14], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_13], ExecError> { +) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2281,21 +2300,21 @@ fn aiur_fn_13( let __v_50: G = __b2_add.0; let __v_51: G = __b2_add.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_13] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_14] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_14: usize = 8; -const IN_14: usize = 8; -const OUT_14: usize = 8; -fn aiur_fn_14( - inp: [G; IN_14], +const INPUT_SIZE_15: usize = 8; +const IN_15: usize = 8; +const OUT_15: usize = 8; +fn aiur_fn_15( + inp: [G; IN_15], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_14], ExecError> { +) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2329,8 +2348,8 @@ fn aiur_fn_14( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -2343,8 +2362,8 @@ fn aiur_fn_14( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2358,8 +2377,8 @@ fn aiur_fn_14( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2372,8 +2391,8 @@ fn aiur_fn_14( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2385,8 +2404,8 @@ fn aiur_fn_14( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2397,8 +2416,8 @@ fn aiur_fn_14( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2408,8 +2427,8 @@ fn aiur_fn_14( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2418,8 +2437,8 @@ fn aiur_fn_14( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); - let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2427,23 +2446,23 @@ fn aiur_fn_14( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); - let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_15: usize = 8; -const IN_15: usize = 8; -const OUT_15: usize = 8; -fn aiur_fn_15( - inp: [G; IN_15], +const INPUT_SIZE_16: usize = 8; +const IN_16: usize = 8; +const OUT_16: usize = 8; +fn aiur_fn_16( + inp: [G; IN_16], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_15], ExecError> { +) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2477,8 +2496,8 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -2491,8 +2510,8 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(255); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 - __v_15); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2506,8 +2525,8 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(255); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 - __v_14); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2520,8 +2539,8 @@ fn aiur_fn_15( let __v_12: G = G::from_u64(255); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 - __v_13); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2533,8 +2552,8 @@ fn aiur_fn_15( let __v_11: G = G::from_u64(255); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 - __v_12); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2545,8 +2564,8 @@ fn aiur_fn_15( let __v_10: G = G::from_u64(255); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2556,8 +2575,8 @@ fn aiur_fn_15( let __v_9: G = G::from_u64(255); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2566,8 +2585,8 @@ fn aiur_fn_15( let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -2575,23 +2594,23 @@ fn aiur_fn_15( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 - __v_8); - let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_16: usize = 8; -const IN_16: usize = 8; -const OUT_16: usize = 1; -fn aiur_fn_16( - inp: [G; IN_16], +const INPUT_SIZE_17: usize = 8; +const IN_17: usize = 8; +const OUT_17: usize = 1; +fn aiur_fn_17( + inp: [G; IN_17], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_16], ExecError> { +) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2623,21 +2642,21 @@ fn aiur_fn_16( let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); - let __ret: [G; OUT_16] = [__v_26]; - if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_17] = [__v_26]; + if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_17: usize = 4; -const IN_17: usize = 4; -const OUT_17: usize = 1; -fn aiur_fn_17( - inp: [G; IN_17], +const INPUT_SIZE_18: usize = 4; +const IN_18: usize = 4; +const OUT_18: usize = 1; +fn aiur_fn_18( + inp: [G; IN_18], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_17], ExecError> { +) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2652,21 +2671,21 @@ fn aiur_fn_17( let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); - let __ret: [G; OUT_17] = [__v_12]; - if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_18] = [__v_12]; + if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_18: usize = 32; -const IN_18: usize = 32; -const OUT_18: usize = 8; -fn aiur_fn_18( - inp: [G; IN_18], +const INPUT_SIZE_19: usize = 32; +const IN_19: usize = 32; +const OUT_19: usize = 8; +fn aiur_fn_19( + inp: [G; IN_19], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_18], ExecError> { +) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2772,21 +2791,21 @@ fn aiur_fn_18( let __v_101: G = (__v_98 + __v_100); let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); - let __ret: [G; OUT_18] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_19] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; + if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_19: usize = 1; -const IN_19: usize = 1; -const OUT_19: usize = 32; -fn aiur_fn_19( - inp: [G; IN_19], +const INPUT_SIZE_20: usize = 1; +const IN_20: usize = 1; +const OUT_20: usize = 32; +fn aiur_fn_20( + inp: [G; IN_20], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_19], ExecError> { +) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -2839,9 +2858,9 @@ fn aiur_fn_19( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -2874,21 +2893,21 @@ fn aiur_fn_19( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __ret: [G; OUT_19] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_20] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; + if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_20: usize = 33; -const IN_20: usize = 33; -const OUT_20: usize = 0; -fn aiur_fn_20( - inp: [G; IN_20], +const INPUT_SIZE_21: usize = 33; +const IN_21: usize = 33; +const OUT_21: usize = 0; +fn aiur_fn_21( + inp: [G; IN_21], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_20], ExecError> { +) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2973,9 +2992,9 @@ fn aiur_fn_20( let __v_80: G = G::from_u64(1); let __v_81: G = G::from_u64(1); let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -3104,21 +3123,21 @@ fn aiur_fn_20( if (__v_115 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } - let __ret: [G; OUT_20] = []; - if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_21] = []; + if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_21: usize = 1; -const IN_21: usize = 1; -const OUT_21: usize = 1; -fn aiur_fn_21( - inp: [G; IN_21], +const INPUT_SIZE_22: usize = 1; +const IN_22: usize = 1; +const OUT_22: usize = 1; +fn aiur_fn_22( + inp: [G; IN_22], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_21], ExecError> { +) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -3171,9 +3190,9 @@ fn aiur_fn_21( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -3207,21 +3226,21 @@ fn aiur_fn_21( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_21] = [__v_84]; - if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_22] = [__v_84]; + if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_22: usize = 34; -const IN_22: usize = 34; -const OUT_22: usize = 34; -fn aiur_fn_22( - inp: [G; IN_22], +const INPUT_SIZE_23: usize = 34; +const IN_23: usize = 34; +const OUT_23: usize = 34; +fn aiur_fn_23( + inp: [G; IN_23], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_22], ExecError> { +) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -3295,13 +3314,13 @@ fn aiur_fn_22( match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); - let __ret: [G; OUT_22] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; @@ -3339,8 +3358,8 @@ fn aiur_fn_22( match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); - let __ret: [G; OUT_22] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -3449,7 +3468,7 @@ fn aiur_fn_22( let __v_202: G = G::from_u64(0); let __v_203: G = G::from_u64(0); let __v_204: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -3486,8 +3505,8 @@ fn aiur_fn_22( let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_22] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -3523,7 +3542,7 @@ fn aiur_fn_22( let __v_200: G = G::from_u64(0); let __v_201: G = G::from_u64(0); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __v_205: G = __r_arr[2]; @@ -3560,8 +3579,8 @@ fn aiur_fn_22( let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_22] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -3578,15 +3597,15 @@ fn aiur_fn_22( }) } -const INPUT_SIZE_23: usize = 1; -const IN_23: usize = 1; -const OUT_23: usize = 32; -fn aiur_fn_23( - inp: [G; IN_23], +const INPUT_SIZE_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 32; +fn aiur_fn_24( + inp: [G; IN_24], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_23], ExecError> { +) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; @@ -3663,13 +3682,13 @@ fn aiur_fn_23( let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_23] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; + if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; @@ -3706,7 +3725,7 @@ fn aiur_fn_23( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; @@ -3739,14 +3758,14 @@ fn aiur_fn_23( let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; - let __ret: [G; OUT_23] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; + if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; @@ -3779,8 +3798,8 @@ fn aiur_fn_23( let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; - let __ret: [G; OUT_23] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; + if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -3797,15 +3816,15 @@ fn aiur_fn_23( }) } -const INPUT_SIZE_24: usize = 7; -const IN_24: usize = 7; -const OUT_24: usize = 1; -fn aiur_fn_24( - inp: [G; IN_24], +const INPUT_SIZE_25: usize = 7; +const IN_25: usize = 7; +const OUT_25: usize = 1; +fn aiur_fn_25( + inp: [G; IN_25], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_24], ExecError> { +) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -3820,10 +3839,10 @@ fn aiur_fn_24( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_10]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_10]; + if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -3831,10 +3850,10 @@ fn aiur_fn_24( let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_12]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_12]; + if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -3842,10 +3861,10 @@ fn aiur_fn_24( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_16]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_16]; + if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -3857,15 +3876,15 @@ fn aiur_fn_24( }) } -const INPUT_SIZE_25: usize = 1; -const IN_25: usize = 1; -const OUT_25: usize = 64; -fn aiur_fn_25( - inp: [G; IN_25], +const INPUT_SIZE_26: usize = 1; +const IN_26: usize = 1; +const OUT_26: usize = 64; +fn aiur_fn_26( + inp: [G; IN_26], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_25], ExecError> { +) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -4252,8 +4271,8 @@ fn aiur_fn_25( let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_25] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_26] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; + if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -4578,22 +4597,22 @@ fn aiur_fn_25( }) } -const INPUT_SIZE_26: usize = 2; -const IN_26: usize = 2; -const OUT_26: usize = 1; -fn aiur_fn_26( - inp: [G; IN_26], +const INPUT_SIZE_27: usize = 2; +const IN_27: usize = 2; +const OUT_27: usize = 1; +fn aiur_fn_27( + inp: [G; IN_27], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_26], ExecError> { +) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_26] = [__v_0]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_27] = [__v_0]; + if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -4602,25 +4621,25 @@ fn aiur_fn_26( let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_26] = [__v_7]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_27] = [__v_7]; + if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_27: usize = 6; -const IN_27: usize = 6; -const OUT_27: usize = 1; -fn aiur_fn_27( - inp: [G; IN_27], +const INPUT_SIZE_28: usize = 6; +const IN_28: usize = 6; +const OUT_28: usize = 1; +fn aiur_fn_28( + inp: [G; IN_28], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_27], ExecError> { +) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -4793,7 +4812,7 @@ fn aiur_fn_27( let __v_145: G = G::from_u64(0); let __v_146: G = G::from_u64(0); let __v_147: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -4827,62 +4846,62 @@ fn aiur_fn_27( let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_180]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_180]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -4923,8 +4942,8 @@ fn aiur_fn_27( let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_42]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_42]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -4939,7 +4958,7 @@ fn aiur_fn_27( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4949,9 +4968,9 @@ fn aiur_fn_27( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -5082,7 +5101,7 @@ fn aiur_fn_27( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -5116,23 +5135,23 @@ fn aiur_fn_27( let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_187]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_187]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_28: usize = 6; -const IN_28: usize = 6; -const OUT_28: usize = 1; -fn aiur_fn_28( - inp: [G; IN_28], +const INPUT_SIZE_29: usize = 6; +const IN_29: usize = 6; +const OUT_29: usize = 1; +fn aiur_fn_29( + inp: [G; IN_29], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_28], ExecError> { +) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -5143,7 +5162,7 @@ fn aiur_fn_28( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -5210,7 +5229,7 @@ fn aiur_fn_28( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __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]; @@ -5221,7 +5240,7 @@ fn aiur_fn_28( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -5325,7 +5344,7 @@ fn aiur_fn_28( let __v_180: G = G::from_u64(0); let __v_181: G = G::from_u64(0); let __v_182: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_183: G = __r_arr[0]; let __v_184: G = __r_arr[1]; let __v_185: G = __r_arr[2]; @@ -5373,7 +5392,7 @@ fn aiur_fn_28( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -5384,17 +5403,17 @@ fn aiur_fn_28( let __v_236: G = __r_arr[7]; let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; - let __ret: [G; OUT_28] = [__v_239]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_29] = [__v_239]; + if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __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]; @@ -5405,7 +5424,7 @@ fn aiur_fn_28( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -5481,7 +5500,7 @@ fn aiur_fn_28( let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; let __v_159: G = __r_arr[2]; @@ -5521,25 +5540,25 @@ fn aiur_fn_28( let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; - let __ret: [G; OUT_28] = [__v_196]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_29] = [__v_196]; + if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_29: usize = 24; -const IN_29: usize = 24; -const OUT_29: usize = 16; -fn aiur_fn_29( - inp: [G; IN_29], +const INPUT_SIZE_30: usize = 24; +const IN_30: usize = 24; +const OUT_30: usize = 16; +fn aiur_fn_30( + inp: [G; IN_30], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_29], ExecError> { +) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -5669,21 +5688,21 @@ fn aiur_fn_29( let __v_89: G = (__v_82 + __v_85); let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); - let __ret: [G; OUT_29] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_30] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; + if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_30: usize = 128; -const IN_30: usize = 128; -const OUT_30: usize = 128; -fn aiur_fn_30( - inp: [G; IN_30], +const INPUT_SIZE_31: usize = 128; +const IN_31: usize = 128; +const OUT_31: usize = 128; +fn aiur_fn_31( + inp: [G; IN_31], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_30], ExecError> { +) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -6645,21 +6664,21 @@ fn aiur_fn_30( let __v_669: G = (__v_662 + __v_665); let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); - let __ret: [G; OUT_30] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_31] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; + if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_31: usize = 106; -const IN_31: usize = 106; -const OUT_31: usize = 32; -fn aiur_fn_31( - inp: [G; IN_31], +const INPUT_SIZE_32: usize = 106; +const IN_32: usize = 106; +const OUT_32: usize = 32; +fn aiur_fn_32( + inp: [G; IN_32], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_31], ExecError> { +) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -6790,7 +6809,7 @@ fn aiur_fn_31( let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -6823,21 +6842,21 @@ fn aiur_fn_31( let __v_158: G = __r_arr[29]; let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; - let __ret: [G; OUT_31] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; + if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_32: usize = 129; -const IN_32: usize = 129; -const OUT_32: usize = 32; -fn aiur_fn_32( - inp: [G; IN_32], +const INPUT_SIZE_33: usize = 129; +const IN_33: usize = 129; +const OUT_33: usize = 32; +fn aiur_fn_33( + inp: [G; IN_33], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_32], ExecError> { +) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7002,8 +7021,8 @@ fn aiur_fn_32( let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; - let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_33] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; + if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -7841,7 +7860,7 @@ fn aiur_fn_32( let __v_672: G = (__v_667 + __v_662); let __v_673: G = G::from_u64(1); let __v_674: G = (__v_0 + __v_673); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_675: G = __r_arr[0]; let __v_676: G = __r_arr[1]; let __v_677: G = __r_arr[2]; @@ -7874,294 +7893,16 @@ fn aiur_fn_32( let __v_704: G = __r_arr[29]; let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; - let __ret: [G; OUT_32] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } - }) -} - -const INPUT_SIZE_33: usize = 19; -const IN_33: usize = 19; -const OUT_33: usize = 1; -fn aiur_fn_33( - inp: [G; IN_33], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_33], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - match __v_0.as_canonical_u64() { - 0u64 => { - let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = G::from_u64(3); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 4u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_19: G = __loaded[0]; - let __v_20: G = __loaded[1]; - let __v_21: G = __loaded[2]; - let __v_22: G = __loaded[3]; - let __v_23: G = __loaded[4]; - let __v_24: G = __loaded[5]; - let __v_25: G = __loaded[6]; - let __v_26: G = __loaded[7]; - let __v_27: G = __loaded[8]; - let __v_28: G = __loaded[9]; - let __v_29: G = __loaded[10]; - let __v_30: G = __loaded[11]; - let __v_31: G = __loaded[12]; - let __v_32: G = __loaded[13]; - let __v_33: G = __loaded[14]; - let __v_34: G = __loaded[15]; - let __v_35: G = __loaded[16]; - let __v_36: G = __loaded[17]; - let __v_37: G = G::from_u64(4); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_40]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 5u64 => { - let __v_19: G = G::from_u64(5); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 6u64 => { - let __v_19: G = G::from_u64(6); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 7u64 => { - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 8u64 => { - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 9u64 => { - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; + let __ret: [G; OUT_33] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, - 10u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_19: G = __loaded[0]; - let __v_20: G = __loaded[1]; - let __v_21: G = __loaded[2]; - let __v_22: G = __loaded[3]; - let __v_23: G = __loaded[4]; - let __v_24: G = __loaded[5]; - let __v_25: G = __loaded[6]; - let __v_26: G = __loaded[7]; - let __v_27: G = __loaded[8]; - let __v_28: G = __loaded[9]; - let __v_29: G = __loaded[10]; - let __v_30: G = __loaded[11]; - let __v_31: G = __loaded[12]; - let __v_32: G = __loaded[13]; - let __v_33: G = __loaded[14]; - let __v_34: G = __loaded[15]; - let __v_35: G = __loaded[16]; - let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_37: G = __loaded[0]; - let __v_38: G = __loaded[1]; - let __v_39: G = __loaded[2]; - let __v_40: G = __loaded[3]; - let __v_41: G = __loaded[4]; - let __v_42: G = __loaded[5]; - let __v_43: G = __loaded[6]; - let __v_44: G = __loaded[7]; - let __v_45: G = __loaded[8]; - let __v_46: G = __loaded[9]; - let __v_47: G = __loaded[10]; - let __v_48: G = __loaded[11]; - let __v_49: G = __loaded[12]; - let __v_50: G = __loaded[13]; - let __v_51: G = __loaded[14]; - let __v_52: G = __loaded[15]; - let __v_53: G = __loaded[16]; - let __v_54: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_55: G = __loaded[0]; - let __v_56: G = __loaded[1]; - let __v_57: G = __loaded[2]; - let __v_58: G = __loaded[3]; - let __v_59: G = __loaded[4]; - let __v_60: G = __loaded[5]; - let __v_61: G = __loaded[6]; - let __v_62: G = __loaded[7]; - let __v_63: G = __loaded[8]; - let __v_64: G = __loaded[9]; - let __v_65: G = __loaded[10]; - let __v_66: G = __loaded[11]; - let __v_67: G = __loaded[12]; - let __v_68: G = __loaded[13]; - let __v_69: G = __loaded[14]; - let __v_70: G = __loaded[15]; - let __v_71: G = __loaded[16]; - let __v_72: G = __loaded[17]; - let __v_73: G = G::from_u64(10); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_77: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_77]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 11u64 => { - let __v_19: G = G::from_u64(11); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); - }, } }) } -const INPUT_SIZE_34: usize = 10; -const IN_34: usize = 10; +const INPUT_SIZE_34: usize = 19; +const IN_34: usize = 19; const OUT_34: usize = 1; fn aiur_fn_34( inp: [G; IN_34], @@ -8180,37 +7921,315 @@ fn aiur_fn_34( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - match __v_8.as_canonical_u64() { + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_34] = [__v_9]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_20]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_20]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(2); + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_30]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(3); + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_30]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 4u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __v_37: G = G::from_u64(4); + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_40]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 5u64 => { + let __v_19: G = G::from_u64(5); + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_20]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __v_19: G = G::from_u64(6); + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_20]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(7); + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_29]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(8); + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_29]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 9u64 => { + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(9); + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_29]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 10u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_55: G = __loaded[0]; + let __v_56: G = __loaded[1]; + let __v_57: G = __loaded[2]; + let __v_58: G = __loaded[3]; + let __v_59: G = __loaded[4]; + let __v_60: G = __loaded[5]; + let __v_61: G = __loaded[6]; + let __v_62: G = __loaded[7]; + let __v_63: G = __loaded[8]; + let __v_64: G = __loaded[9]; + let __v_65: G = __loaded[10]; + let __v_66: G = __loaded[11]; + let __v_67: G = __loaded[12]; + let __v_68: G = __loaded[13]; + let __v_69: G = __loaded[14]; + let __v_70: G = __loaded[15]; + let __v_71: G = __loaded[16]; + let __v_72: G = __loaded[17]; + let __v_73: G = G::from_u64(10); + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_77]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 11u64 => { + let __v_19: G = G::from_u64(11); + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_34] = [__v_20]; if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_35: usize = 10; +const IN_35: usize = 10; +const OUT_35: usize = 1; +fn aiur_fn_35( + inp: [G; IN_35], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_35], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_35] = [__v_9]; + if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_8 - __v_12); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_34] = [__v_15]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_35] = [__v_15]; + if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_35: usize = 9; -const IN_35: usize = 9; -const OUT_35: usize = 1; -fn aiur_fn_35( - inp: [G; IN_35], +const INPUT_SIZE_36: usize = 9; +const IN_36: usize = 9; +const OUT_36: usize = 1; +fn aiur_fn_36( + inp: [G; IN_36], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_35], ExecError> { +) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8221,7 +8240,7 @@ fn aiur_fn_35( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(128); let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) }; @@ -8231,8 +8250,8 @@ fn aiur_fn_35( 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_13]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_13]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8241,11 +8260,11 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_18]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -8256,26 +8275,26 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_18]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_36: usize = 10; -const IN_36: usize = 10; -const OUT_36: usize = 1; -fn aiur_fn_36( - inp: [G; IN_36], +const INPUT_SIZE_37: usize = 10; +const IN_37: usize = 10; +const OUT_37: usize = 1; +fn aiur_fn_37( + inp: [G; IN_37], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_36], ExecError> { +) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8287,7 +8306,7 @@ fn aiur_fn_36( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8300,8 +8319,8 @@ fn aiur_fn_36( let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_17]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_17]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8313,11 +8332,11 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_22]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -8331,26 +8350,26 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_22]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_37: usize = 10; -const IN_37: usize = 10; -const OUT_37: usize = 1; -fn aiur_fn_37( - inp: [G; IN_37], +const INPUT_SIZE_38: usize = 10; +const IN_38: usize = 10; +const OUT_38: usize = 1; +fn aiur_fn_38( + inp: [G; IN_38], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_37], ExecError> { +) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8362,7 +8381,7 @@ fn aiur_fn_37( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8375,8 +8394,8 @@ fn aiur_fn_37( let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_17]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_17]; + if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8388,11 +8407,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_22]; + if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -8406,26 +8425,26 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_22]; + if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_38: usize = 2; -const IN_38: usize = 2; -const OUT_38: usize = 1; -fn aiur_fn_38( - inp: [G; IN_38], +const INPUT_SIZE_39: usize = 2; +const IN_39: usize = 2; +const OUT_39: usize = 1; +fn aiur_fn_39( + inp: [G; IN_39], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_38], ExecError> { +) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8442,200 +8461,35 @@ fn aiur_fn_38( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_38] = [__v_1]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_39] = [__v_1]; + if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_38] = [__v_13]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_39: usize = 2; -const IN_39: usize = 2; -const OUT_39: usize = 1; -fn aiur_fn_39( - inp: [G; IN_39], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_39], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - match __v_0.as_canonical_u64() { - 0u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4]; + let __ret: [G; OUT_39] = [__v_13]; if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_40: usize = 3; -const IN_40: usize = 3; -const OUT_40: usize = 1; +const INPUT_SIZE_40: usize = 18; +const IN_40: usize = 18; +const OUT_40: usize = 8; fn aiur_fn_40( inp: [G; IN_40], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - match __v_0.as_canonical_u64() { - 0u64 => { - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(0); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(4); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }, - 1u64 => { - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(5); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }, - 2u64 => { - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(2); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(6); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }, - 3u64 => { - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(3); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(7); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_40] = [__v_5]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_41: usize = 18; -const IN_41: usize = 18; -const OUT_41: usize = 8; -fn aiur_fn_41( - inp: [G; IN_41], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8676,7 +8530,7 @@ fn aiur_fn_41( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8685,7 +8539,7 @@ fn aiur_fn_41( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8694,8 +8548,8 @@ fn aiur_fn_41( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8707,23 +8561,23 @@ fn aiur_fn_41( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_42: usize = 18; -const IN_42: usize = 18; -const OUT_42: usize = 8; -fn aiur_fn_42( - inp: [G; IN_42], +const INPUT_SIZE_41: usize = 18; +const IN_41: usize = 18; +const OUT_41: usize = 8; +fn aiur_fn_41( + inp: [G; IN_41], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_42], ExecError> { +) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8745,7 +8599,7 @@ fn aiur_fn_42( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8764,7 +8618,7 @@ fn aiur_fn_42( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8773,7 +8627,7 @@ fn aiur_fn_42( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8782,8 +8636,8 @@ fn aiur_fn_42( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8795,23 +8649,23 @@ fn aiur_fn_42( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_43: usize = 18; -const IN_43: usize = 18; -const OUT_43: usize = 8; -fn aiur_fn_43( - inp: [G; IN_43], +const INPUT_SIZE_42: usize = 18; +const IN_42: usize = 18; +const OUT_42: usize = 8; +fn aiur_fn_42( + inp: [G; IN_42], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_43], ExecError> { +) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8833,7 +8687,7 @@ fn aiur_fn_43( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8852,7 +8706,7 @@ fn aiur_fn_43( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8861,7 +8715,7 @@ fn aiur_fn_43( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8870,8 +8724,8 @@ fn aiur_fn_43( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8883,23 +8737,23 @@ fn aiur_fn_43( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_44: usize = 19; -const IN_44: usize = 19; -const OUT_44: usize = 1; -fn aiur_fn_44( - inp: [G; IN_44], +const INPUT_SIZE_43: usize = 19; +const IN_43: usize = 19; +const OUT_43: usize = 1; +fn aiur_fn_43( + inp: [G; IN_43], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_44], ExecError> { +) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8960,34 +8814,34 @@ fn aiur_fn_44( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_56]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_56]; + if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_19]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_19]; + if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_45: usize = 19; -const IN_45: usize = 19; -const OUT_45: usize = 1; -fn aiur_fn_45( - inp: [G; IN_45], +const INPUT_SIZE_44: usize = 19; +const IN_44: usize = 19; +const OUT_44: usize = 1; +fn aiur_fn_44( + inp: [G; IN_44], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_45], ExecError> { +) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9010,7 +8864,7 @@ fn aiur_fn_45( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9029,7 +8883,7 @@ fn aiur_fn_45( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -9048,36 +8902,34 @@ fn aiur_fn_45( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_1, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_45] = [__v_57]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_56]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_45] = [__v_19]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_19]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_46: usize = 19; -const IN_46: usize = 19; -const OUT_46: usize = 1; -fn aiur_fn_46( - inp: [G; IN_46], +const INPUT_SIZE_45: usize = 19; +const IN_45: usize = 19; +const OUT_45: usize = 1; +fn aiur_fn_45( + inp: [G; IN_45], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_46], ExecError> { +) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9100,7 +8952,7 @@ fn aiur_fn_46( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9119,7 +8971,7 @@ fn aiur_fn_46( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -9138,36 +8990,34 @@ fn aiur_fn_46( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_46] = [__v_57]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_56]; + if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_46] = [__v_19]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_19]; + if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_47: usize = 2; -const IN_47: usize = 2; -const OUT_47: usize = 1; -fn aiur_fn_47( - inp: [G; IN_47], +const INPUT_SIZE_46: usize = 2; +const IN_46: usize = 2; +const OUT_46: usize = 1; +fn aiur_fn_46( + inp: [G; IN_46], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_47], ExecError> { +) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9268,21 +9118,21 @@ fn aiur_fn_47( let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_96: G = G::from_u64(0); let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_47] = [__v_97]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_46] = [__v_97]; + if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_48: usize = 2; -const IN_48: usize = 2; -const OUT_48: usize = 1; -fn aiur_fn_48( - inp: [G; IN_48], +const INPUT_SIZE_47: usize = 2; +const IN_47: usize = 2; +const OUT_47: usize = 1; +fn aiur_fn_47( + inp: [G; IN_47], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_48], ExecError> { +) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9291,20 +9141,20 @@ fn aiur_fn_48( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9316,20 +9166,20 @@ fn aiur_fn_48( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(4); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9341,20 +9191,20 @@ fn aiur_fn_48( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(8); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); - let __ret: [G; OUT_48] = [__v_2]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9369,15 +9219,15 @@ fn aiur_fn_48( }) } -const INPUT_SIZE_49: usize = 9; -const IN_49: usize = 9; -const OUT_49: usize = 8; -fn aiur_fn_49( - inp: [G; IN_49], +const INPUT_SIZE_48: usize = 9; +const IN_48: usize = 9; +const OUT_48: usize = 8; +fn aiur_fn_48( + inp: [G; IN_48], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_49], ExecError> { +) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9400,7 +9250,7 @@ fn aiur_fn_49( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9409,7 +9259,7 @@ fn aiur_fn_49( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -9418,8 +9268,8 @@ fn aiur_fn_49( let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; - let __ret: [G; OUT_49] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_48] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9431,23 +9281,23 @@ fn aiur_fn_49( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_50: usize = 9; -const IN_50: usize = 9; -const OUT_50: usize = 9; -fn aiur_fn_50( - inp: [G; IN_50], +const INPUT_SIZE_49: usize = 9; +const IN_49: usize = 9; +const OUT_49: usize = 9; +fn aiur_fn_49( + inp: [G; IN_49], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_50], ExecError> { +) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9470,7 +9320,7 @@ fn aiur_fn_50( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9480,28 +9330,28 @@ fn aiur_fn_50( let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; - let __ret: [G; OUT_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_51: usize = 10; -const IN_51: usize = 10; -const OUT_51: usize = 1; -fn aiur_fn_51( - inp: [G; IN_51], +const INPUT_SIZE_50: usize = 10; +const IN_50: usize = 10; +const OUT_50: usize = 1; +fn aiur_fn_50( + inp: [G; IN_50], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_51], ExecError> { +) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9518,12 +9368,12 @@ fn aiur_fn_51( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_51] = [__v_12]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_12]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -9532,7 +9382,7 @@ fn aiur_fn_51( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9543,12 +9393,12 @@ fn aiur_fn_51( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_29]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_29]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { @@ -9581,14 +9431,14 @@ fn aiur_fn_51( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_39]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_39]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { @@ -9621,22 +9471,22 @@ fn aiur_fn_51( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_39]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_39]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_11]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_11]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9646,15 +9496,15 @@ fn aiur_fn_51( }) } -const INPUT_SIZE_52: usize = 2; -const IN_52: usize = 2; -const OUT_52: usize = 1; -fn aiur_fn_52( - inp: [G; IN_52], +const INPUT_SIZE_51: usize = 2; +const IN_51: usize = 2; +const OUT_51: usize = 1; +fn aiur_fn_51( + inp: [G; IN_51], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_52], ExecError> { +) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9664,8 +9514,8 @@ fn aiur_fn_52( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_52] = [__v_1]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_1]; + if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -9688,12 +9538,12 @@ fn aiur_fn_52( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_52] = [__v_24]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_24]; + if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9703,15 +9553,15 @@ fn aiur_fn_52( }) } -const INPUT_SIZE_53: usize = 2; -const IN_53: usize = 2; -const OUT_53: usize = 1; -fn aiur_fn_53( - inp: [G; IN_53], +const INPUT_SIZE_52: usize = 2; +const IN_52: usize = 2; +const OUT_52: usize = 1; +fn aiur_fn_52( + inp: [G; IN_52], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_53], ExecError> { +) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9721,8 +9571,8 @@ fn aiur_fn_53( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_53] = [__v_1]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_1]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -9736,12 +9586,12 @@ fn aiur_fn_53( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_53] = [__v_15]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_15]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9751,15 +9601,15 @@ fn aiur_fn_53( }) } -const INPUT_SIZE_54: usize = 2; -const IN_54: usize = 2; -const OUT_54: usize = 1; -fn aiur_fn_54( - inp: [G; IN_54], +const INPUT_SIZE_53: usize = 2; +const IN_53: usize = 2; +const OUT_53: usize = 1; +fn aiur_fn_53( + inp: [G; IN_53], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_54], ExecError> { +) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9769,17 +9619,17 @@ fn aiur_fn_54( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_54] = [__v_1]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_1]; + if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_54] = [__v_6]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_6]; + if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9789,6 +9639,58 @@ fn aiur_fn_54( }) } +const INPUT_SIZE_54: usize = 2; +const IN_54: usize = 2; +const OUT_54: usize = 1; +fn aiur_fn_54( + inp: [G; IN_54], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_54], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_54] = [__v_4]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_54] = [__v_4]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_54] = [__v_4]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(3); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_54] = [__v_4]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + const INPUT_SIZE_55: usize = 13; const IN_55: usize = 13; const OUT_55: usize = 1; @@ -9852,14 +9754,14 @@ fn aiur_fn_55( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_55] = [__v_54]; @@ -9911,9 +9813,9 @@ fn aiur_fn_56( let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_29]; if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10048,7 +9950,7 @@ fn aiur_fn_58( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -10060,19 +9962,19 @@ fn aiur_fn_58( let __v_74: G = G::from_u64(0); let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_58] = [__v_83]; @@ -10126,9 +10028,9 @@ fn aiur_fn_59( let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_59] = [__v_32]; @@ -10181,11 +10083,11 @@ fn aiur_fn_60( let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_31]; if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10262,15 +10164,15 @@ fn aiur_fn_61( let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_61] = [__v_59]; @@ -10411,7 +10313,7 @@ fn aiur_fn_63( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10423,15 +10325,15 @@ fn aiur_fn_63( let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_63] = [__v_61]; @@ -10464,9 +10366,9 @@ fn aiur_fn_64( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_64] = [__v_11]; if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10506,11 +10408,11 @@ fn aiur_fn_65( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_20]; if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10828,7 +10730,7 @@ fn aiur_fn_69( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10837,9 +10739,9 @@ fn aiur_fn_69( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_11]; if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10859,7 +10761,7 @@ fn aiur_fn_70( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10868,9 +10770,9 @@ fn aiur_fn_70( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_11]; if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10890,7 +10792,7 @@ fn aiur_fn_71( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10899,9 +10801,9 @@ fn aiur_fn_71( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_11]; if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10978,7 +10880,7 @@ fn aiur_fn_72( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -10990,7 +10892,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(12); let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11008,7 +10910,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11026,7 +10928,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11044,7 +10946,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11062,7 +10964,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11080,7 +10982,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11098,7 +11000,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11116,7 +11018,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11134,7 +11036,7 @@ fn aiur_fn_72( let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_62]; if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -11518,7 +11420,7 @@ fn aiur_fn_78( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -11540,7 +11442,7 @@ fn aiur_fn_78( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11585,7 +11487,7 @@ fn aiur_fn_79( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -11594,13 +11496,13 @@ fn aiur_fn_79( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -11623,8 +11525,8 @@ fn aiur_fn_79( }) } -const INPUT_SIZE_80: usize = 1; -const IN_80: usize = 1; +const INPUT_SIZE_80: usize = 9; +const IN_80: usize = 9; const OUT_80: usize = 2; fn aiur_fn_80( inp: [G; IN_80], @@ -11632,158 +11534,6 @@ fn aiur_fn_80( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_4: G = G::from_u64(4); - let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; - let __v_6: G = G::from_u64(1); - if (__v_5 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid lambda mode".to_string()) }); - } - match __v_2.as_canonical_u64() { - 0u64 => { - let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_80] = [__v_7, __v_3]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_80] = [__v_7, __v_3]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __v_7: G = G::from_u64(2); - let __ret: [G; OUT_80] = [__v_7, __v_3]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __v_7: G = G::from_u64(3); - let __ret: [G; OUT_80] = [__v_7, __v_3]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_81: usize = 1; -const IN_81: usize = 1; -const OUT_81: usize = 3; -fn aiur_fn_81( - inp: [G; IN_81], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_81], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - match __v_1.as_canonical_u64() { - 0u64 => { - let __v_4: G = G::from_u64(8); - let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; - let __v_6: G = G::from_u64(1); - if (__v_5 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid forall mode".to_string()) }); - } - match __v_2.as_canonical_u64() { - 0u64 => { - let __v_7: G = G::from_u64(0); - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __v_7: G = G::from_u64(2); - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __v_7: G = G::from_u64(3); - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 4u64 => { - let __v_7: G = G::from_u64(0); - let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 5u64 => { - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 6u64 => { - let __v_7: G = G::from_u64(2); - let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 7u64 => { - let __v_7: G = G::from_u64(3); - let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_82: usize = 9; -const IN_82: usize = 9; -const OUT_82: usize = 2; -fn aiur_fn_82( - inp: [G; IN_82], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11794,74 +11544,38 @@ fn aiur_fn_82( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_12: G = __loaded[0]; - let __v_13: G = __loaded[1]; - let __v_14: G = __loaded[2]; - let __v_15: G = __loaded[3]; - let __v_16: G = __loaded[4]; - let __v_17: G = __loaded[5]; - let __v_18: G = __loaded[6]; - let __v_19: G = __loaded[7]; - let __v_20: G = __loaded[8]; - let __v_21: G = __loaded[9]; - let __v_22: G = __loaded[10]; - let __v_23: G = __loaded[11]; - let __v_24: G = __loaded[12]; - let __v_25: G = __loaded[13]; - let __v_26: G = __loaded[14]; - let __v_27: G = __loaded[15]; - let __v_28: G = __loaded[16]; - let __v_29: G = __loaded[17]; - match __v_12.as_canonical_u64() { - 8u64 => { - let __v_30: G = G::from_u64(0); - let __v_31: G = G::from_u64(1); - if (__v_30 != __v_31) { - return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) }); - } - let __ret: [G; OUT_82] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __ret: [G; OUT_82] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __ret: [G; OUT_80] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __v_15: G = __r_arr[1]; - let __v_16: G = __r_arr[2]; - let __v_17: G = __r_arr[3]; - let __v_18: G = __r_arr[4]; - let __v_19: G = __r_arr[5]; - let __v_20: G = __r_arr[6]; - let __v_21: G = __r_arr[7]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __v_23: G = __r_arr[1]; - let __v_24: G = G::from_u64(8); - let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_26, __v_23]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(8); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_80] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11871,15 +11585,15 @@ fn aiur_fn_82( }) } -const INPUT_SIZE_83: usize = 9; -const IN_83: usize = 9; -const OUT_83: usize = 2; -fn aiur_fn_83( - inp: [G; IN_83], +const INPUT_SIZE_81: usize = 9; +const IN_81: usize = 9; +const OUT_81: usize = 2; +fn aiur_fn_81( + inp: [G; IN_81], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_83], ExecError> { +) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11890,75 +11604,38 @@ fn aiur_fn_83( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_12: G = __loaded[0]; - let __v_13: G = __loaded[1]; - let __v_14: G = __loaded[2]; - let __v_15: G = __loaded[3]; - let __v_16: G = __loaded[4]; - let __v_17: G = __loaded[5]; - let __v_18: G = __loaded[6]; - let __v_19: G = __loaded[7]; - let __v_20: G = __loaded[8]; - let __v_21: G = __loaded[9]; - let __v_22: G = __loaded[10]; - let __v_23: G = __loaded[11]; - let __v_24: G = __loaded[12]; - let __v_25: G = __loaded[13]; - let __v_26: G = __loaded[14]; - let __v_27: G = __loaded[15]; - let __v_28: G = __loaded[16]; - let __v_29: G = __loaded[17]; - match __v_12.as_canonical_u64() { - 9u64 => { - let __v_30: G = G::from_u64(0); - let __v_31: G = G::from_u64(1); - if (__v_30 != __v_31) { - return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) }); - } - let __ret: [G; OUT_83] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __ret: [G; OUT_83] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __ret: [G; OUT_81] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - let __v_16: G = __r_arr[1]; - let __v_17: G = __r_arr[2]; - let __v_18: G = __r_arr[3]; - let __v_19: G = __r_arr[4]; - let __v_20: G = __r_arr[5]; - let __v_21: G = __r_arr[6]; - let __v_22: G = __r_arr[7]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__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[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; - let __v_23: G = __r_arr[0]; - let __v_24: G = __r_arr[1]; - let __v_25: G = G::from_u64(9); - let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_83] = [__v_27, __v_24]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(9); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_81] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11968,15 +11645,15 @@ fn aiur_fn_83( }) } -const INPUT_SIZE_84: usize = 1; -const IN_84: usize = 1; -const OUT_84: usize = 2; -fn aiur_fn_84( - inp: [G; IN_84], +const INPUT_SIZE_82: usize = 1; +const IN_82: usize = 1; +const OUT_82: usize = 2; +fn aiur_fn_82( + inp: [G; IN_82], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_84], ExecError> { +) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; @@ -11995,16 +11672,16 @@ fn aiur_fn_84( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { @@ -12024,8 +11701,8 @@ fn aiur_fn_84( let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { @@ -12045,8 +11722,8 @@ fn aiur_fn_84( let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -12060,126 +11737,90 @@ fn aiur_fn_84( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); } - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_15: G = __loaded[0]; - let __v_16: G = __loaded[1]; - let __v_17: G = __loaded[2]; - let __v_18: G = __loaded[3]; - let __v_19: G = __loaded[4]; - let __v_20: G = __loaded[5]; - let __v_21: G = __loaded[6]; - let __v_22: G = __loaded[7]; - let __v_23: G = __loaded[8]; - let __v_24: G = __loaded[9]; - let __v_25: G = __loaded[10]; - let __v_26: G = __loaded[11]; - let __v_27: G = __loaded[12]; - let __v_28: G = __loaded[13]; - let __v_29: G = __loaded[14]; - let __v_30: G = __loaded[15]; - let __v_31: G = __loaded[16]; - let __v_32: G = __loaded[17]; - match __v_15.as_canonical_u64() { - 7u64 => { - let __v_33: G = G::from_u64(0); - let __v_34: G = G::from_u64(1); - if (__v_33 != __v_34) { - return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) }); - } - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; - let __v_35: G = __r_arr[0]; - let __v_36: G = __r_arr[1]; - let __ret: [G; OUT_84] = [__v_35, __v_36]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __v_34: G = __r_arr[1]; - let __ret: [G; OUT_84] = [__v_33, __v_34]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __ret: [G; OUT_82] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); } - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_84] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); } - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_84] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__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[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_84] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_84] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12189,15 +11830,15 @@ fn aiur_fn_84( }) } -const INPUT_SIZE_85: usize = 9; -const IN_85: usize = 9; -const OUT_85: usize = 2; -fn aiur_fn_85( - inp: [G; IN_85], +const INPUT_SIZE_83: usize = 9; +const IN_83: usize = 9; +const OUT_83: usize = 2; +fn aiur_fn_83( + inp: [G; IN_83], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_85], ExecError> { +) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12208,58 +11849,33 @@ fn aiur_fn_85( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __v_9: G = G::from_u64(0); - let __v_10: G = G::from_u64(0); - let __v_11: G = G::from_u64(0); - let __v_12: G = G::from_u64(0); - let __v_13: G = G::from_u64(0); - let __v_14: G = G::from_u64(0); - let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = G::from_u64(10); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __v_18: G = G::from_u64(1); - let __v_19: G = G::from_u64(0); - let __v_20: G = G::from_u64(0); - let __v_21: G = G::from_u64(0); - let __v_22: G = G::from_u64(0); - let __v_23: G = G::from_u64(0); - let __v_24: G = G::from_u64(0); - let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; - let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; - let __v_31: G = __r_arr[0]; - let __v_32: G = __r_arr[1]; - let __v_33: G = (__v_17 + __v_26); - let __v_34: G = G::from_u64(1); - if (__v_33 != __v_34) { - return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("invalid let nonDep flag".to_string()) }); - } - let __v_35: G = G::from_u64(10); - let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27, __v_29, __v_31, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_85] = [__v_37, __v_32]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_83] = [__v_17, __v_14]; + if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_86: usize = 17; -const IN_86: usize = 17; -const OUT_86: usize = 9; -fn aiur_fn_86( - inp: [G; IN_86], +const INPUT_SIZE_84: usize = 17; +const IN_84: usize = 17; +const OUT_84: usize = 9; +fn aiur_fn_84( + inp: [G; IN_84], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_86], ExecError> { +) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12278,16 +11894,16 @@ fn aiur_fn_86( let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_86] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -12296,7 +11912,7 @@ fn aiur_fn_86( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -12309,8 +11925,8 @@ fn aiur_fn_86( let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_86] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_84] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; + if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12320,15 +11936,15 @@ fn aiur_fn_86( }) } -const INPUT_SIZE_87: usize = 1; -const IN_87: usize = 1; -const OUT_87: usize = 10; -fn aiur_fn_87( - inp: [G; IN_87], +const INPUT_SIZE_85: usize = 1; +const IN_85: usize = 1; +const OUT_85: usize = 10; +fn aiur_fn_85( + inp: [G; IN_85], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_87], ExecError> { +) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; @@ -12344,18 +11960,18 @@ fn aiur_fn_87( let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_87] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12366,7 +11982,7 @@ fn aiur_fn_87( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -12376,8 +11992,8 @@ fn aiur_fn_87( let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; - let __ret: [G; OUT_87] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12386,7 +12002,7 @@ fn aiur_fn_87( } }, 1u64 => { - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12397,7 +12013,7 @@ fn aiur_fn_87( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12412,12 +12028,12 @@ fn aiur_fn_87( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_87] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12428,7 +12044,7 @@ fn aiur_fn_87( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12443,14 +12059,14 @@ fn aiur_fn_87( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_87] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); - let __ret: [G; OUT_87] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12460,15 +12076,15 @@ fn aiur_fn_87( }) } -const INPUT_SIZE_88: usize = 1; -const IN_88: usize = 1; -const OUT_88: usize = 2; -fn aiur_fn_88( - inp: [G; IN_88], +const INPUT_SIZE_86: usize = 1; +const IN_86: usize = 1; +const OUT_86: usize = 2; +fn aiur_fn_86( + inp: [G; IN_86], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_88], ExecError> { +) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -12664,8 +12280,8 @@ fn aiur_fn_88( match __v_94.as_canonical_u64() { 0u64 => { let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_97, __v_96]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_86] = [__v_97, __v_96]; + if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12830,15 +12446,15 @@ fn aiur_fn_88( }) } -const INPUT_SIZE_89: usize = 9; -const IN_89: usize = 9; -const OUT_89: usize = 2; -fn aiur_fn_89( - inp: [G; IN_89], +const INPUT_SIZE_87: usize = 9; +const IN_87: usize = 9; +const OUT_87: usize = 2; +fn aiur_fn_87( + inp: [G; IN_87], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_89], ExecError> { +) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12849,22 +12465,22 @@ fn aiur_fn_89( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_89] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12873,13 +12489,13 @@ fn aiur_fn_89( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_89] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12889,15 +12505,15 @@ fn aiur_fn_89( }) } -const INPUT_SIZE_90: usize = 9; -const IN_90: usize = 9; -const OUT_90: usize = 2; -fn aiur_fn_90( - inp: [G; IN_90], +const INPUT_SIZE_88: usize = 9; +const IN_88: usize = 9; +const OUT_88: usize = 2; +fn aiur_fn_88( + inp: [G; IN_88], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_90], ExecError> { +) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12908,19 +12524,19 @@ fn aiur_fn_90( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_90] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12931,7 +12547,7 @@ fn aiur_fn_90( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12940,14 +12556,14 @@ fn aiur_fn_90( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_90] = [__v_32, __v_29]; - if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_32, __v_29]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12957,15 +12573,15 @@ fn aiur_fn_90( }) } -const INPUT_SIZE_91: usize = 9; -const IN_91: usize = 9; -const OUT_91: usize = 2; -fn aiur_fn_91( - inp: [G; IN_91], +const INPUT_SIZE_89: usize = 9; +const IN_89: usize = 9; +const OUT_89: usize = 2; +fn aiur_fn_89( + inp: [G; IN_89], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_91], ExecError> { +) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12976,22 +12592,22 @@ fn aiur_fn_91( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_91] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_89] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13000,13 +12616,13 @@ fn aiur_fn_91( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__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[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_91] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_89] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13016,15 +12632,15 @@ fn aiur_fn_91( }) } -const INPUT_SIZE_92: usize = 1; -const IN_92: usize = 1; -const OUT_92: usize = 2; -fn aiur_fn_92( - inp: [G; IN_92], +const INPUT_SIZE_90: usize = 1; +const IN_90: usize = 1; +const OUT_90: usize = 2; +fn aiur_fn_90( + inp: [G; IN_90], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_92], ExecError> { +) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13037,24 +12653,24 @@ fn aiur_fn_92( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_92] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_90] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 1; -const IN_93: usize = 1; -const OUT_93: usize = 2; -fn aiur_fn_93( - inp: [G; IN_93], +const INPUT_SIZE_91: usize = 1; +const IN_91: usize = 1; +const OUT_91: usize = 2; +fn aiur_fn_91( + inp: [G; IN_91], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_93], ExecError> { +) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13067,24 +12683,24 @@ fn aiur_fn_93( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_93] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_91] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 2; -fn aiur_fn_94( - inp: [G; IN_94], +const INPUT_SIZE_92: usize = 1; +const IN_92: usize = 1; +const OUT_92: usize = 2; +fn aiur_fn_92( + inp: [G; IN_92], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_94], ExecError> { +) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13097,88 +12713,88 @@ fn aiur_fn_94( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_94] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_92] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_95: usize = 1; -const IN_95: usize = 1; -const OUT_95: usize = 2; -fn aiur_fn_95( - inp: [G; IN_95], +const INPUT_SIZE_93: usize = 1; +const IN_93: usize = 1; +const OUT_93: usize = 2; +fn aiur_fn_93( + inp: [G; IN_93], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_95], ExecError> { +) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_95] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13188,21 +12804,21 @@ fn aiur_fn_95( }) } -const INPUT_SIZE_96: usize = 1; -const IN_96: usize = 1; -const OUT_96: usize = 13; -fn aiur_fn_96( - inp: [G; IN_96], +const INPUT_SIZE_94: usize = 1; +const IN_94: usize = 1; +const OUT_94: usize = 13; +fn aiur_fn_94( + inp: [G; IN_94], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_96], ExecError> { +) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13215,27 +12831,27 @@ fn aiur_fn_96( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_96] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; - if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_94] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; + if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_97: usize = 1; -const IN_97: usize = 1; -const OUT_97: usize = 10; -fn aiur_fn_97( - inp: [G; IN_97], +const INPUT_SIZE_95: usize = 1; +const IN_95: usize = 1; +const OUT_95: usize = 10; +fn aiur_fn_95( + inp: [G; IN_95], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_97], ExecError> { +) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13248,24 +12864,24 @@ fn aiur_fn_97( 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_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_97] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_95] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_98: usize = 9; -const IN_98: usize = 9; -const OUT_98: usize = 2; -fn aiur_fn_98( - inp: [G; IN_98], +const INPUT_SIZE_96: usize = 9; +const IN_96: usize = 9; +const OUT_96: usize = 2; +fn aiur_fn_96( + inp: [G; IN_96], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_98], ExecError> { +) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13276,15 +12892,15 @@ fn aiur_fn_98( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_98] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13298,10 +12914,10 @@ fn aiur_fn_98( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -13310,13 +12926,13 @@ fn aiur_fn_98( let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__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[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_98] = [__v_32, __v_30]; - if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_32, __v_30]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13326,15 +12942,15 @@ fn aiur_fn_98( }) } -const INPUT_SIZE_99: usize = 1; -const IN_99: usize = 1; -const OUT_99: usize = 45; -fn aiur_fn_99( - inp: [G; IN_99], +const INPUT_SIZE_97: usize = 1; +const IN_97: usize = 1; +const OUT_97: usize = 45; +fn aiur_fn_97( + inp: [G; IN_97], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_99], ExecError> { +) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -13399,7 +13015,7 @@ fn aiur_fn_99( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13412,24 +13028,24 @@ fn aiur_fn_99( let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; - let __ret: [G; OUT_99] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_97] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; + if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_100: usize = 1; -const IN_100: usize = 1; -const OUT_100: usize = 0; -fn aiur_fn_100( - inp: [G; IN_100], +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 0; +fn aiur_fn_98( + inp: [G; IN_98], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_100], ExecError> { +) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(2); @@ -13438,27 +13054,27 @@ fn aiur_fn_100( if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } - let __ret: [G; OUT_100] = []; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_98] = []; + if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_101: usize = 1; -const IN_101: usize = 1; -const OUT_101: usize = 11; -fn aiur_fn_101( - inp: [G; IN_101], +const INPUT_SIZE_99: usize = 1; +const IN_99: usize = 1; +const OUT_99: usize = 11; +fn aiur_fn_99( + inp: [G; IN_99], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_101], ExecError> { +) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; @@ -13469,49 +13085,49 @@ fn aiur_fn_101( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_101] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; - if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_99] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; + if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_102: usize = 1; -const IN_102: usize = 1; -const OUT_102: usize = 1; -fn aiur_fn_102( - inp: [G; IN_102], +const INPUT_SIZE_100: usize = 1; +const IN_100: usize = 1; +const OUT_100: usize = 1; +fn aiur_fn_100( + inp: [G; IN_100], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_102], ExecError> { +) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_102] = [__v_1]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_102] = [__v_1]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_102] = [__v_1]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); - let __ret: [G; OUT_102] = [__v_1]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13521,21 +13137,21 @@ fn aiur_fn_102( }) } -const INPUT_SIZE_103: usize = 1; -const IN_103: usize = 1; -const OUT_103: usize = 11; -fn aiur_fn_103( - inp: [G; IN_103], +const INPUT_SIZE_101: usize = 1; +const IN_101: usize = 1; +const OUT_101: usize = 11; +fn aiur_fn_101( + inp: [G; IN_101], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_103], ExecError> { +) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -13547,30 +13163,30 @@ fn aiur_fn_103( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_103] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; + if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_104: usize = 1; -const IN_104: usize = 1; -const OUT_104: usize = 35; -fn aiur_fn_104( - inp: [G; IN_104], +const INPUT_SIZE_102: usize = 1; +const IN_102: usize = 1; +const OUT_102: usize = 35; +fn aiur_fn_102( + inp: [G; IN_102], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_104], ExecError> { +) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; @@ -13611,24 +13227,24 @@ fn aiur_fn_104( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __ret: [G; OUT_104] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; - if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_105: usize = 9; -const IN_105: usize = 9; -const OUT_105: usize = 2; -fn aiur_fn_105( - inp: [G; IN_105], +const INPUT_SIZE_103: usize = 9; +const IN_103: usize = 9; +const OUT_103: usize = 2; +fn aiur_fn_103( + inp: [G; IN_103], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_105], ExecError> { +) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13639,19 +13255,19 @@ fn aiur_fn_105( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_105] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13687,7 +13303,7 @@ fn aiur_fn_105( let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -13696,13 +13312,13 @@ fn aiur_fn_105( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_105] = [__v_56, __v_54]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_56, __v_54]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13712,15 +13328,15 @@ fn aiur_fn_105( }) } -const INPUT_SIZE_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 28; -fn aiur_fn_106( - inp: [G; IN_106], +const INPUT_SIZE_104: usize = 1; +const IN_104: usize = 1; +const OUT_104: usize = 28; +fn aiur_fn_104( + inp: [G; IN_104], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_106], ExecError> { +) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -13765,7 +13381,7 @@ fn aiur_fn_106( 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_84] = { let __args: [G; IN_84] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13778,24 +13394,24 @@ fn aiur_fn_106( let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __ret: [G; OUT_106] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 10; -fn aiur_fn_107( - inp: [G; IN_107], +const INPUT_SIZE_105: usize = 1; +const IN_105: usize = 1; +const OUT_105: usize = 10; +fn aiur_fn_105( + inp: [G; IN_105], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_107], ExecError> { +) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13808,24 +13424,24 @@ fn aiur_fn_107( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_108: usize = 1; -const IN_108: usize = 1; -const OUT_108: usize = 18; -fn aiur_fn_108( - inp: [G; IN_108], +const INPUT_SIZE_106: usize = 1; +const IN_106: usize = 1; +const OUT_106: usize = 18; +fn aiur_fn_106( + inp: [G; IN_106], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_108], ExecError> { +) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -13848,24 +13464,24 @@ fn aiur_fn_108( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_106] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; + if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_109: usize = 1; -const IN_109: usize = 1; -const OUT_109: usize = 46; -fn aiur_fn_109( - inp: [G; IN_109], +const INPUT_SIZE_107: usize = 1; +const IN_107: usize = 1; +const OUT_107: usize = 46; +fn aiur_fn_107( + inp: [G; IN_107], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_109], ExecError> { +) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -13873,7 +13489,7 @@ fn aiur_fn_109( let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13889,12 +13505,12 @@ fn aiur_fn_109( let __v_15: G = __r_arr[12]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13925,12 +13541,12 @@ fn aiur_fn_109( let __v_30: G = __r_arr[27]; let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13977,8 +13593,8 @@ fn aiur_fn_109( let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); - let __ret: [G; OUT_109] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13988,15 +13604,15 @@ fn aiur_fn_109( }) } -const INPUT_SIZE_110: usize = 9; -const IN_110: usize = 9; -const OUT_110: usize = 2; -fn aiur_fn_110( - inp: [G; IN_110], +const INPUT_SIZE_108: usize = 9; +const IN_108: usize = 9; +const OUT_108: usize = 2; +fn aiur_fn_108( + inp: [G; IN_108], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_110], ExecError> { +) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14007,19 +13623,19 @@ fn aiur_fn_110( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_110] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -14066,7 +13682,7 @@ fn aiur_fn_110( let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -14075,13 +13691,13 @@ fn aiur_fn_110( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_110] = [__v_67, __v_65]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_67, __v_65]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14091,21 +13707,21 @@ fn aiur_fn_110( }) } -const INPUT_SIZE_111: usize = 2; -const IN_111: usize = 2; -const OUT_111: usize = 46; -fn aiur_fn_111( - inp: [G; IN_111], +const INPUT_SIZE_109: usize = 2; +const IN_109: usize = 2; +const OUT_109: usize = 46; +fn aiur_fn_109( + inp: [G; IN_109], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_111], ExecError> { +) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14121,12 +13737,12 @@ fn aiur_fn_111( let __v_14: G = __r_arr[12]; let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14173,12 +13789,12 @@ fn aiur_fn_111( let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); - let __ret: [G; OUT_111] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14192,12 +13808,12 @@ fn aiur_fn_111( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14211,12 +13827,12 @@ fn aiur_fn_111( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14237,12 +13853,12 @@ fn aiur_fn_111( let __v_19: G = __r_arr[17]; let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14255,12 +13871,12 @@ fn aiur_fn_111( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14273,12 +13889,12 @@ fn aiur_fn_111( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14291,8 +13907,8 @@ fn aiur_fn_111( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_111] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14302,15 +13918,15 @@ fn aiur_fn_111( }) } -const INPUT_SIZE_112: usize = 10; -const IN_112: usize = 10; -const OUT_112: usize = 46; -fn aiur_fn_112( - inp: [G; IN_112], +const INPUT_SIZE_110: usize = 10; +const IN_110: usize = 10; +const OUT_110: usize = 46; +fn aiur_fn_110( + inp: [G; IN_110], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_112], ExecError> { +) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14324,13 +13940,13 @@ fn aiur_fn_112( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_112] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 13u64 => { @@ -14344,7 +13960,7 @@ fn aiur_fn_112( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -14391,8 +14007,8 @@ fn aiur_fn_112( let __v_60: G = __r_arr[43]; let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; - let __ret: [G; OUT_112] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14402,15 +14018,15 @@ fn aiur_fn_112( }) } -const INPUT_SIZE_113: usize = 1; -const IN_113: usize = 1; -const OUT_113: usize = 49; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_111: usize = 1; +const IN_111: usize = 1; +const OUT_111: usize = 49; +fn aiur_fn_111( + inp: [G; IN_111], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; @@ -14426,7 +14042,7 @@ fn aiur_fn_113( let __v_10: G = __r_arr[9]; let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__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[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); @@ -14444,7 +14060,7 @@ fn aiur_fn_113( if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -14554,7 +14170,7 @@ fn aiur_fn_113( 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_89] = { let __args: [G; IN_89] = [__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[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -14567,7 +14183,7 @@ fn aiur_fn_113( let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -14580,24 +14196,24 @@ fn aiur_fn_113( let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __ret: [G; OUT_113] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_114: usize = 1; -const IN_114: usize = 1; -const OUT_114: usize = 2; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_112: usize = 1; +const IN_112: usize = 1; +const OUT_112: usize = 2; +fn aiur_fn_112( + inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -14607,36 +14223,36 @@ fn aiur_fn_114( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_114] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_114] = [__v_0, __v_7]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_0, __v_7]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_115: usize = 1; -const IN_115: usize = 1; -const OUT_115: usize = 1; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_113: usize = 1; +const IN_113: usize = 1; +const OUT_113: usize = 1; +fn aiur_fn_113( + inp: [G; IN_113], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -14665,8 +14281,8 @@ fn aiur_fn_115( let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_115] = [__v_23]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_23]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14678,7 +14294,7 @@ fn aiur_fn_115( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -14692,17 +14308,17 @@ fn aiur_fn_115( 0u64 => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_115] = [__v_29]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_29]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_115] = [__v_30]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_30]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14714,15 +14330,15 @@ fn aiur_fn_115( }) } -const INPUT_SIZE_116: usize = 3; -const IN_116: usize = 3; -const OUT_116: usize = 1; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_114: usize = 3; +const IN_114: usize = 3; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14742,15 +14358,15 @@ fn aiur_fn_116( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_116] = [__v_1]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_1]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_116] = [__v_13]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_13]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14771,21 +14387,21 @@ fn aiur_fn_116( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_116] = [__v_0]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_0]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_116] = [__v_23]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_23]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14802,7 +14418,7 @@ fn aiur_fn_116( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14814,11 +14430,11 @@ fn aiur_fn_116( let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_51]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_51]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14833,36 +14449,36 @@ fn aiur_fn_116( }) } -const INPUT_SIZE_117: usize = 2; -const IN_117: usize = 2; -const OUT_117: usize = 1; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_115: usize = 2; +const IN_115: usize = 2; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_117] = [__v_3]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_115] = [__v_3]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_118: usize = 16; -const IN_118: usize = 16; -const OUT_118: usize = 9; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_116: usize = 16; +const IN_116: usize = 16; +const OUT_116: usize = 9; +fn aiur_fn_116( + inp: [G; IN_116], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14932,21 +14548,21 @@ fn aiur_fn_118( let __v_50: G = __b2_sub.0; let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_118] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_119: usize = 3; -const IN_119: usize = 3; -const OUT_119: usize = 2; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_117: usize = 3; +const IN_117: usize = 3; +const OUT_117: usize = 2; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14980,20 +14596,20 @@ fn aiur_fn_119( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_25, __v_2]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_25, __v_2]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_26, __v_2]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_26, __v_2]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15001,8 +14617,8 @@ fn aiur_fn_119( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_119] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -15029,8 +14645,8 @@ fn aiur_fn_119( match __v_2.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_119] = [__v_0, __v_23]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_0, __v_23]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15042,7 +14658,7 @@ fn aiur_fn_119( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -15055,19 +14671,19 @@ fn aiur_fn_119( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_46, __v_44]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_46, __v_44]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -15084,7 +14700,7 @@ fn aiur_fn_119( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -15095,13 +14711,13 @@ fn aiur_fn_119( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_52, __v_50]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_52, __v_50]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15116,15 +14732,15 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 1; -const IN_120: usize = 1; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_118: usize = 1; +const IN_118: usize = 1; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -15143,8 +14759,8 @@ fn aiur_fn_120( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_13]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15153,11 +14769,11 @@ fn aiur_fn_120( if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_13]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15167,15 +14783,15 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_119: usize = 1; +const IN_119: usize = 1; +const OUT_119: usize = 1; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -15194,12 +14810,12 @@ fn aiur_fn_121( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_13]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_13]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -15214,15 +14830,15 @@ fn aiur_fn_121( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_25]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_25]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15231,8 +14847,8 @@ fn aiur_fn_121( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_27]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_27]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15243,8 +14859,8 @@ fn aiur_fn_121( _ => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_23]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_23]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -15256,20 +14872,20 @@ fn aiur_fn_121( }) } -const INPUT_SIZE_122: usize = 2; -const IN_122: usize = 2; -const OUT_122: usize = 1; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_120: usize = 2; +const IN_120: usize = 2; +const OUT_120: usize = 1; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -15277,15 +14893,15 @@ fn aiur_fn_122( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_7]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_7]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_122] = [__v_5]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_5]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15295,19 +14911,19 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 2; -const IN_123: usize = 2; -const OUT_123: usize = 1; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_121: usize = 2; +const IN_121: usize = 2; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -15323,29 +14939,29 @@ fn aiur_fn_123( match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_123] = [__v_13]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_123] = [__v_13]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_124: usize = 1; -const IN_124: usize = 1; -const OUT_124: usize = 1; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_122: usize = 1; +const IN_122: usize = 1; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -15361,23 +14977,23 @@ fn aiur_fn_124( let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_124] = [__v_14]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_14]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_125: usize = 2; -const IN_125: usize = 2; -const OUT_125: usize = 2; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_123: usize = 2; +const IN_123: usize = 2; +const OUT_123: usize = 2; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15385,8 +15001,8 @@ fn aiur_fn_125( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_125] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15394,11 +15010,11 @@ fn aiur_fn_125( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_125] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15408,40 +15024,40 @@ fn aiur_fn_125( }) } -const INPUT_SIZE_126: usize = 1; -const IN_126: usize = 1; -const OUT_126: usize = 3; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 3; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_126] = [__v_2, __v_5, __v_6]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_2, __v_5, __v_6]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_127: usize = 16; -const IN_127: usize = 16; -const OUT_127: usize = 16; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_125: usize = 16; +const IN_125: usize = 16; +const OUT_125: usize = 16; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15572,7 +15188,7 @@ fn aiur_fn_127( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -15595,7 +15211,7 @@ fn aiur_fn_127( if (__v_16 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -15618,7 +15234,7 @@ fn aiur_fn_127( if (__v_141 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; @@ -15641,7 +15257,7 @@ fn aiur_fn_127( if (__v_160 != __v_185) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; @@ -15664,7 +15280,7 @@ fn aiur_fn_127( if (__v_179 != __v_204) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -15687,7 +15303,7 @@ fn aiur_fn_127( if (__v_198 != __v_223) { return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; @@ -15710,7 +15326,7 @@ fn aiur_fn_127( if (__v_217 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; @@ -15733,7 +15349,7 @@ fn aiur_fn_127( if (__v_236 != __v_261) { return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; @@ -15756,7 +15372,7 @@ fn aiur_fn_127( if (__v_255 != __v_280) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; @@ -15779,7 +15395,7 @@ fn aiur_fn_127( if (__v_274 != __v_299) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; @@ -15802,7 +15418,7 @@ fn aiur_fn_127( if (__v_293 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; @@ -15825,7 +15441,7 @@ fn aiur_fn_127( if (__v_312 != __v_337) { return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; @@ -15848,7 +15464,7 @@ fn aiur_fn_127( if (__v_331 != __v_356) { return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; @@ -15871,7 +15487,7 @@ fn aiur_fn_127( if (__v_350 != __v_375) { return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; @@ -15894,7 +15510,7 @@ fn aiur_fn_127( if (__v_369 != __v_394) { return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_124] = { let __args: [G; IN_124] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; @@ -15916,21 +15532,21 @@ fn aiur_fn_127( if (__v_388 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) }); } - let __ret: [G; OUT_127] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_128: usize = 2; -const IN_128: usize = 2; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_126: usize = 2; +const IN_126: usize = 2; +const OUT_126: usize = 1; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15938,23 +15554,23 @@ fn aiur_fn_128( let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_6]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_6]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_129: usize = 4; -const IN_129: usize = 4; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_127: usize = 4; +const IN_127: usize = 4; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15973,8 +15589,8 @@ fn aiur_fn_129( let __v_13: G = __loaded[9]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_129] = [__v_2]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_2]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15989,18 +15605,18 @@ fn aiur_fn_129( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_129] = [__v_30]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_30]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16010,15 +15626,15 @@ fn aiur_fn_129( }) } -const INPUT_SIZE_130: usize = 18; -const IN_130: usize = 18; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_128: usize = 18; +const IN_128: usize = 18; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16051,19 +15667,19 @@ fn aiur_fn_130( let __v_27: G = __loaded[9]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_130] = [__v_17]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_17]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_130] = [__v_29]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_29]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16072,7 +15688,7 @@ fn aiur_fn_130( } }, 0u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -16089,7 +15705,7 @@ fn aiur_fn_130( let __v_41: G = __r_arr[13]; let __v_42: G = __r_arr[14]; let __v_43: G = __r_arr[15]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -16106,7 +15722,7 @@ fn aiur_fn_130( let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __v_62: G = __r_arr[2]; @@ -16116,12 +15732,12 @@ fn aiur_fn_130( let __v_66: G = __r_arr[6]; let __v_67: G = __r_arr[7]; let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_130] = [__v_70]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_70]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16131,22 +15747,22 @@ fn aiur_fn_130( }) } -const INPUT_SIZE_131: usize = 2; -const IN_131: usize = 2; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_129: usize = 2; +const IN_129: usize = 2; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_131] = [__v_0]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_0]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16162,28 +15778,28 @@ fn aiur_fn_131( let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_131] = [__v_14]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_14]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_132: usize = 1; -const IN_132: usize = 1; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_130: usize = 1; +const IN_130: usize = 1; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -16199,79 +15815,79 @@ fn aiur_fn_132( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_132] = [__v_12]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_12]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_132] = [__v_12]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_12]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_133: usize = 2; -const IN_133: usize = 2; -const OUT_133: usize = 2; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 2; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } - let __ret: [G; OUT_133] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } - let __ret: [G; OUT_133] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16281,75 +15897,75 @@ fn aiur_fn_133( }) } -const INPUT_SIZE_134: usize = 2; -const IN_134: usize = 2; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_132: usize = 2; +const IN_132: usize = 2; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_134] = [__v_2]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_2]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_135: usize = 2; -const IN_135: usize = 2; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_133: usize = 2; +const IN_133: usize = 2; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_135] = [__v_3]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_133] = [__v_3]; + if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_136: usize = 2; -const IN_136: usize = 2; -const OUT_136: usize = 1; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_134: usize = 2; +const IN_134: usize = 2; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_136] = [__v_0]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_0]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_136] = [__v_4]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_4]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16359,19 +15975,19 @@ fn aiur_fn_136( }) } -const INPUT_SIZE_137: usize = 2; -const IN_137: usize = 2; -const OUT_137: usize = 1; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_135: usize = 2; +const IN_135: usize = 2; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -16388,8 +16004,8 @@ fn aiur_fn_137( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_137] = [__v_15]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_15]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16406,30 +16022,30 @@ fn aiur_fn_137( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_137] = [__v_21]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_21]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_137] = [__v_23]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_23]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16444,15 +16060,15 @@ fn aiur_fn_137( }) } -const INPUT_SIZE_138: usize = 16; -const IN_138: usize = 16; -const OUT_138: usize = 8; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_136: usize = 16; +const IN_136: usize = 16; +const OUT_136: usize = 8; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16478,21 +16094,21 @@ fn aiur_fn_138( let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_139: usize = 16; -const IN_139: usize = 16; -const OUT_139: usize = 8; -fn aiur_fn_139( - inp: [G; IN_139], +const INPUT_SIZE_137: usize = 16; +const IN_137: usize = 16; +const OUT_137: usize = 8; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16518,21 +16134,21 @@ fn aiur_fn_139( let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_140: usize = 16; -const IN_140: usize = 16; -const OUT_140: usize = 8; -fn aiur_fn_140( - inp: [G; IN_140], +const INPUT_SIZE_138: usize = 16; +const IN_138: usize = 16; +const OUT_138: usize = 8; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16558,21 +16174,21 @@ fn aiur_fn_140( let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_141: usize = 2; -const IN_141: usize = 2; -const OUT_141: usize = 1; -fn aiur_fn_141( - inp: [G; IN_141], +const INPUT_SIZE_139: usize = 2; +const IN_139: usize = 2; +const OUT_139: usize = 1; +fn aiur_fn_139( + inp: [G; IN_139], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_141], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16592,8 +16208,8 @@ fn aiur_fn_141( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_141] = [__v_14]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_14]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16613,13 +16229,13 @@ fn aiur_fn_141( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_141] = [__v_24]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_24]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16628,11 +16244,11 @@ fn aiur_fn_141( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_141] = [__v_32]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_32]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16647,15 +16263,15 @@ fn aiur_fn_141( }) } -const INPUT_SIZE_142: usize = 2; -const IN_142: usize = 2; -const OUT_142: usize = 1; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_140: usize = 2; +const IN_140: usize = 2; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16672,8 +16288,8 @@ fn aiur_fn_142( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_142] = [__v_1]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_1]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16690,13 +16306,13 @@ fn aiur_fn_142( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_142] = [__v_0]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_0]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16705,11 +16321,11 @@ fn aiur_fn_142( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_142] = [__v_32]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_32]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16724,15 +16340,15 @@ fn aiur_fn_142( }) } -const INPUT_SIZE_143: usize = 2; -const IN_143: usize = 2; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_141: usize = 2; +const IN_141: usize = 2; +const OUT_141: usize = 1; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16749,8 +16365,8 @@ fn aiur_fn_143( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_143] = [__v_1]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_1]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16767,13 +16383,13 @@ fn aiur_fn_143( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_143] = [__v_0]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_0]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16782,11 +16398,11 @@ fn aiur_fn_143( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_143] = [__v_32]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_32]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16801,15 +16417,15 @@ fn aiur_fn_143( }) } -const INPUT_SIZE_144: usize = 2; -const IN_144: usize = 2; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_142: usize = 2; +const IN_142: usize = 2; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16826,25 +16442,25 @@ fn aiur_fn_144( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_144] = [__v_16]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_16]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_145: usize = 2; -const IN_145: usize = 2; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_143: usize = 2; +const IN_143: usize = 2; +const OUT_143: usize = 1; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16861,11 +16477,109 @@ fn aiur_fn_145( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_145] = [__v_16]; + let __ret: [G; OUT_143] = [__v_16]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_144: usize = 0; +const IN_144: usize = 0; +const OUT_144: usize = 1; +fn aiur_fn_144( + inp: [G; IN_144], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_144], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(211); + let __v_1: G = G::from_u64(151); + 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_144] = [__v_32]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_145: usize = 0; +const IN_145: usize = 0; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_145], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(222); + let __v_1: G = G::from_u64(245); + 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_145] = [__v_32]; if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -16881,38 +16595,38 @@ fn aiur_fn_146( unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(80); - let __v_1: G = G::from_u64(229); - let __v_2: G = G::from_u64(214); - let __v_3: G = G::from_u64(157); - let __v_4: G = G::from_u64(128); - let __v_5: G = G::from_u64(107); - let __v_6: G = G::from_u64(193); - let __v_7: G = G::from_u64(198); - let __v_8: G = G::from_u64(22); - let __v_9: G = G::from_u64(202); - let __v_10: G = G::from_u64(206); - let __v_11: G = G::from_u64(66); - let __v_12: G = G::from_u64(48); - let __v_13: G = G::from_u64(201); - let __v_14: G = G::from_u64(130); - let __v_15: G = G::from_u64(160); - let __v_16: G = G::from_u64(238); - let __v_17: G = G::from_u64(91); - let __v_18: G = G::from_u64(53); - let __v_19: G = G::from_u64(11); - let __v_20: G = G::from_u64(62); - let __v_21: G = G::from_u64(254); - let __v_22: G = G::from_u64(59); - let __v_23: G = G::from_u64(26); - let __v_24: G = G::from_u64(21); - let __v_25: G = G::from_u64(128); - let __v_26: G = G::from_u64(29); - let __v_27: G = G::from_u64(247); - let __v_28: G = G::from_u64(127); - let __v_29: G = G::from_u64(192); - let __v_30: G = G::from_u64(12); - let __v_31: G = G::from_u64(140); + let __v_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_146] = [__v_32]; if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16930,38 +16644,38 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(140); - let __v_1: G = G::from_u64(9); - let __v_2: G = G::from_u64(202); - let __v_3: G = G::from_u64(100); - let __v_4: G = G::from_u64(75); - let __v_5: G = G::from_u64(16); - let __v_6: G = G::from_u64(222); - let __v_7: G = G::from_u64(202); - let __v_8: G = G::from_u64(209); - let __v_9: G = G::from_u64(88); - let __v_10: G = G::from_u64(211); - let __v_11: G = G::from_u64(112); - let __v_12: G = G::from_u64(6); - let __v_13: G = G::from_u64(232); - let __v_14: G = G::from_u64(28); - let __v_15: G = G::from_u64(220); - let __v_16: G = G::from_u64(27); - let __v_17: G = G::from_u64(132); - let __v_18: G = G::from_u64(118); - let __v_19: G = G::from_u64(19); - let __v_20: G = G::from_u64(18); - let __v_21: G = G::from_u64(38); - let __v_22: G = G::from_u64(5); - let __v_23: G = G::from_u64(70); - let __v_24: G = G::from_u64(68); - let __v_25: G = G::from_u64(154); - let __v_26: G = G::from_u64(160); - let __v_27: G = G::from_u64(46); - let __v_28: G = G::from_u64(52); - let __v_29: G = G::from_u64(59); - let __v_30: G = G::from_u64(43); - let __v_31: G = G::from_u64(12); + let __v_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_147] = [__v_32]; if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16979,38 +16693,38 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(252); - let __v_1: G = G::from_u64(233); - let __v_2: G = G::from_u64(22); - let __v_3: G = G::from_u64(207); - let __v_4: G = G::from_u64(60); - let __v_5: G = G::from_u64(109); - let __v_6: G = G::from_u64(208); - let __v_7: G = G::from_u64(26); - let __v_8: G = G::from_u64(216); - let __v_9: G = G::from_u64(198); - let __v_10: G = G::from_u64(211); - let __v_11: G = G::from_u64(134); - let __v_12: G = G::from_u64(65); - let __v_13: G = G::from_u64(188); - let __v_14: G = G::from_u64(167); - let __v_15: G = G::from_u64(179); - let __v_16: G = G::from_u64(238); - let __v_17: G = G::from_u64(172); - let __v_18: G = G::from_u64(91); - let __v_19: G = G::from_u64(201); - let __v_20: G = G::from_u64(59); - let __v_21: G = G::from_u64(53); - let __v_22: G = G::from_u64(41); - let __v_23: G = G::from_u64(173); - let __v_24: G = G::from_u64(120); - let __v_25: G = G::from_u64(18); - let __v_26: G = G::from_u64(118); - let __v_27: G = G::from_u64(139); - let __v_28: G = G::from_u64(52); - let __v_29: G = G::from_u64(7); - let __v_30: G = G::from_u64(214); - let __v_31: G = G::from_u64(78); + let __v_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_148] = [__v_32]; if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17028,38 +16742,38 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(72); - let __v_1: G = G::from_u64(120); - let __v_2: G = G::from_u64(107); - let __v_3: G = G::from_u64(127); - let __v_4: G = G::from_u64(122); - let __v_5: G = G::from_u64(220); - let __v_6: G = G::from_u64(99); - let __v_7: G = G::from_u64(42); - let __v_8: G = G::from_u64(227); - let __v_9: G = G::from_u64(80); - let __v_10: G = G::from_u64(89); - let __v_11: G = G::from_u64(243); - let __v_12: G = G::from_u64(253); - let __v_13: G = G::from_u64(24); - let __v_14: G = G::from_u64(29); - let __v_15: G = G::from_u64(243); - let __v_16: G = G::from_u64(45); - let __v_17: G = G::from_u64(158); - let __v_18: G = G::from_u64(92); - let __v_19: G = G::from_u64(199); - let __v_20: G = G::from_u64(54); - let __v_21: G = G::from_u64(12); - let __v_22: G = G::from_u64(79); - let __v_23: G = G::from_u64(208); - let __v_24: G = G::from_u64(44); - let __v_25: G = G::from_u64(62); - let __v_26: G = G::from_u64(139); - let __v_27: G = G::from_u64(17); - let __v_28: G = G::from_u64(129); - let __v_29: G = G::from_u64(161); - let __v_30: G = G::from_u64(83); - let __v_31: G = G::from_u64(155); + let __v_0: G = G::from_u64(182); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(172); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(228); + let __v_6: G = G::from_u64(111); + let __v_7: G = G::from_u64(139); + let __v_8: G = G::from_u64(134); + let __v_9: G = G::from_u64(64); + let __v_10: G = G::from_u64(41); + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(76); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(148); + let __v_16: G = G::from_u64(203); + let __v_17: G = G::from_u64(205); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(3); + let __v_21: G = G::from_u64(94); + let __v_22: G = G::from_u64(221); + let __v_23: G = G::from_u64(84); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(124); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(44); + let __v_29: G = G::from_u64(159); + let __v_30: G = G::from_u64(233); + let __v_31: G = G::from_u64(38); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_32]; if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17077,38 +16791,38 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(207); - let __v_1: G = G::from_u64(201); - let __v_2: G = G::from_u64(52); - let __v_3: G = G::from_u64(253); - let __v_4: G = G::from_u64(109); - let __v_5: G = G::from_u64(83); - let __v_6: G = G::from_u64(165); - let __v_7: G = G::from_u64(178); - let __v_8: G = G::from_u64(59); - let __v_9: G = G::from_u64(106); - let __v_10: G = G::from_u64(59); - let __v_11: G = G::from_u64(48); - let __v_12: G = G::from_u64(208); - let __v_13: G = G::from_u64(33); - let __v_14: G = G::from_u64(101); - let __v_15: G = G::from_u64(253); - let __v_16: G = G::from_u64(170); - let __v_17: G = G::from_u64(87); - let __v_18: G = G::from_u64(78); - let __v_19: G = G::from_u64(59); - let __v_20: G = G::from_u64(94); - let __v_21: G = G::from_u64(177); - let __v_22: G = G::from_u64(57); - let __v_23: G = G::from_u64(38); - let __v_24: G = G::from_u64(187); - let __v_25: G = G::from_u64(22); - let __v_26: G = G::from_u64(110); - let __v_27: G = G::from_u64(100); - let __v_28: G = G::from_u64(134); - let __v_29: G = G::from_u64(252); - let __v_30: G = G::from_u64(14); - let __v_31: G = G::from_u64(80); + let __v_0: G = G::from_u64(188); + let __v_1: G = G::from_u64(176); + let __v_2: G = G::from_u64(155); + let __v_3: G = G::from_u64(164); + let __v_4: G = G::from_u64(63); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(218); + let __v_7: G = G::from_u64(230); + let __v_8: G = G::from_u64(92); + let __v_9: G = G::from_u64(86); + let __v_10: G = G::from_u64(164); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(247); + let __v_13: G = G::from_u64(123); + let __v_14: G = G::from_u64(80); + let __v_15: G = G::from_u64(180); + let __v_16: G = G::from_u64(46); + let __v_17: G = G::from_u64(222); + let __v_18: G = G::from_u64(18); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(188); + let __v_21: G = G::from_u64(219); + let __v_22: G = G::from_u64(168); + let __v_23: G = G::from_u64(70); + let __v_24: G = G::from_u64(158); + let __v_25: G = G::from_u64(121); + let __v_26: G = G::from_u64(154); + let __v_27: G = G::from_u64(33); + let __v_28: G = G::from_u64(241); + let __v_29: G = G::from_u64(47); + let __v_30: G = G::from_u64(211); + let __v_31: G = G::from_u64(137); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_150] = [__v_32]; if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17126,38 +16840,38 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(30); - let __v_1: G = G::from_u64(96); - let __v_2: G = G::from_u64(189); - let __v_3: G = G::from_u64(55); - let __v_4: G = G::from_u64(122); - let __v_5: G = G::from_u64(116); - let __v_6: G = G::from_u64(108); - let __v_7: G = G::from_u64(183); - let __v_8: G = G::from_u64(189); - let __v_9: G = G::from_u64(122); - let __v_10: G = G::from_u64(229); - let __v_11: G = G::from_u64(65); - let __v_12: G = G::from_u64(215); - let __v_13: G = G::from_u64(223); - let __v_14: G = G::from_u64(178); - let __v_15: G = G::from_u64(55); - let __v_16: G = G::from_u64(9); - let __v_17: G = G::from_u64(125); - let __v_18: G = G::from_u64(136); - let __v_19: G = G::from_u64(61); - let __v_20: G = G::from_u64(40); - let __v_21: G = G::from_u64(236); - let __v_22: G = G::from_u64(122); - let __v_23: G = G::from_u64(173); - let __v_24: G = G::from_u64(215); - let __v_25: G = G::from_u64(50); - let __v_26: G = G::from_u64(192); - let __v_27: G = G::from_u64(103); - let __v_28: G = G::from_u64(78); - let __v_29: G = G::from_u64(13); - let __v_30: G = G::from_u64(185); - let __v_31: G = G::from_u64(100); + let __v_0: G = G::from_u64(116); + let __v_1: G = G::from_u64(237); + let __v_2: G = G::from_u64(31); + let __v_3: G = G::from_u64(185); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(191); + let __v_6: G = G::from_u64(153); + let __v_7: G = G::from_u64(208); + let __v_8: G = G::from_u64(176); + let __v_9: G = G::from_u64(45); + let __v_10: G = G::from_u64(190); + let __v_11: G = G::from_u64(254); + let __v_12: G = G::from_u64(4); + let __v_13: G = G::from_u64(36); + let __v_14: G = G::from_u64(100); + let __v_15: G = G::from_u64(205); + let __v_16: G = G::from_u64(113); + let __v_17: G = G::from_u64(83); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(133); + let __v_20: G = G::from_u64(154); + let __v_21: G = G::from_u64(112); + let __v_22: G = G::from_u64(51); + let __v_23: G = G::from_u64(122); + let __v_24: G = G::from_u64(153); + let __v_25: G = G::from_u64(52); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(231); + let __v_28: G = G::from_u64(98); + let __v_29: G = G::from_u64(220); + let __v_30: G = G::from_u64(190); + let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_151] = [__v_32]; if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17175,38 +16889,38 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(13); - let __v_1: G = G::from_u64(116); - let __v_2: G = G::from_u64(186); - let __v_3: G = G::from_u64(133); - let __v_4: G = G::from_u64(249); - let __v_5: G = G::from_u64(116); - let __v_6: G = G::from_u64(154); - let __v_7: G = G::from_u64(12); - let __v_8: G = G::from_u64(37); - let __v_9: G = G::from_u64(170); - let __v_10: G = G::from_u64(106); - let __v_11: G = G::from_u64(43); - let __v_12: G = G::from_u64(112); - let __v_13: G = G::from_u64(52); - let __v_14: G = G::from_u64(142); - let __v_15: G = G::from_u64(87); - let __v_16: G = G::from_u64(231); - let __v_17: G = G::from_u64(9); - let __v_18: G = G::from_u64(131); - let __v_19: G = G::from_u64(31); - let __v_20: G = G::from_u64(183); - let __v_21: G = G::from_u64(204); - let __v_22: G = G::from_u64(5); - let __v_23: G = G::from_u64(34); - let __v_24: G = G::from_u64(159); - let __v_25: G = G::from_u64(236); - let __v_26: G = G::from_u64(215); - let __v_27: G = G::from_u64(214); - let __v_28: G = G::from_u64(106); - let __v_29: G = G::from_u64(223); - let __v_30: G = G::from_u64(24); - let __v_31: G = G::from_u64(77); + let __v_0: G = G::from_u64(246); + let __v_1: G = G::from_u64(28); + let __v_2: G = G::from_u64(125); + let __v_3: G = G::from_u64(63); + let __v_4: G = G::from_u64(206); + let __v_5: G = G::from_u64(89); + let __v_6: G = G::from_u64(84); + let __v_7: G = G::from_u64(48); + let __v_8: G = G::from_u64(248); + let __v_9: G = G::from_u64(111); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(213); + let __v_12: G = G::from_u64(45); + let __v_13: G = G::from_u64(165); + let __v_14: G = G::from_u64(188); + let __v_15: G = G::from_u64(176); + let __v_16: G = G::from_u64(11); + let __v_17: G = G::from_u64(249); + let __v_18: G = G::from_u64(16); + let __v_19: G = G::from_u64(237); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(94); + let __v_22: G = G::from_u64(20); + let __v_23: G = G::from_u64(220); + let __v_24: G = G::from_u64(4); + let __v_25: G = G::from_u64(2); + let __v_26: G = G::from_u64(19); + let __v_27: G = G::from_u64(15); + let __v_28: G = G::from_u64(204); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(78); + let __v_31: G = G::from_u64(189); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_152] = [__v_32]; if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17224,38 +16938,38 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(197); - let __v_1: G = G::from_u64(190); - let __v_2: G = G::from_u64(246); - let __v_3: G = G::from_u64(190); - let __v_4: G = G::from_u64(108); - let __v_5: G = G::from_u64(63); - let __v_6: G = G::from_u64(220); - let __v_7: G = G::from_u64(82); - let __v_8: G = G::from_u64(4); - let __v_9: G = G::from_u64(84); - let __v_10: G = G::from_u64(193); - let __v_11: G = G::from_u64(30); - let __v_12: G = G::from_u64(153); - let __v_13: G = G::from_u64(80); - let __v_14: G = G::from_u64(235); - let __v_15: G = G::from_u64(47); - let __v_16: G = G::from_u64(26); - let __v_17: G = G::from_u64(108); - let __v_18: G = G::from_u64(146); - let __v_19: G = G::from_u64(244); - let __v_20: G = G::from_u64(26); - let __v_21: G = G::from_u64(100); - let __v_22: G = G::from_u64(107); - let __v_23: G = G::from_u64(92); - let __v_24: G = G::from_u64(161); - let __v_25: G = G::from_u64(104); - let __v_26: G = G::from_u64(255); - let __v_27: G = G::from_u64(25); - let __v_28: G = G::from_u64(143); - let __v_29: G = G::from_u64(19); - let __v_30: G = G::from_u64(197); - let __v_31: G = G::from_u64(90); + let __v_0: G = G::from_u64(172); + let __v_1: G = G::from_u64(156); + let __v_2: G = G::from_u64(114); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(149); + let __v_5: G = G::from_u64(81); + let __v_6: G = G::from_u64(245); + let __v_7: G = G::from_u64(99); + let __v_8: G = G::from_u64(127); + let __v_9: G = G::from_u64(124); + let __v_10: G = G::from_u64(81); + let __v_11: G = G::from_u64(199); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(230); + let __v_14: G = G::from_u64(218); + let __v_15: G = G::from_u64(143); + let __v_16: G = G::from_u64(214); + let __v_17: G = G::from_u64(106); + let __v_18: G = G::from_u64(129); + let __v_19: G = G::from_u64(131); + let __v_20: G = G::from_u64(124); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(181); + let __v_23: G = G::from_u64(12); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(14); + let __v_27: G = G::from_u64(207); + let __v_28: G = G::from_u64(140); + let __v_29: G = G::from_u64(187); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(112); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_153] = [__v_32]; if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17273,38 +16987,38 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(188); - let __v_1: G = G::from_u64(97); - let __v_2: G = G::from_u64(193); - let __v_3: G = G::from_u64(15); - let __v_4: G = G::from_u64(204); - let __v_5: G = G::from_u64(166); - let __v_6: G = G::from_u64(65); - let __v_7: G = G::from_u64(82); - let __v_8: G = G::from_u64(35); - let __v_9: G = G::from_u64(237); - let __v_10: G = G::from_u64(151); - let __v_11: G = G::from_u64(188); - let __v_12: G = G::from_u64(174); - let __v_13: G = G::from_u64(33); - let __v_14: G = G::from_u64(203); - let __v_15: G = G::from_u64(153); - let __v_16: G = G::from_u64(212); - let __v_17: G = G::from_u64(131); - let __v_18: G = G::from_u64(109); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(123); - let __v_21: G = G::from_u64(7); - let __v_22: G = G::from_u64(134); - let __v_23: G = G::from_u64(162); - let __v_24: G = G::from_u64(252); - let __v_25: G = G::from_u64(92); - let __v_26: G = G::from_u64(89); - let __v_27: G = G::from_u64(5); - let __v_28: G = G::from_u64(248); - let __v_29: G = G::from_u64(176); - let __v_30: G = G::from_u64(75); - let __v_31: G = G::from_u64(162); + let __v_0: G = G::from_u64(159); + let __v_1: G = G::from_u64(44); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(227); + let __v_4: G = G::from_u64(222); + let __v_5: G = G::from_u64(58); + let __v_6: G = G::from_u64(121); + let __v_7: G = G::from_u64(79); + let __v_8: G = G::from_u64(103); + let __v_9: G = G::from_u64(219); + let __v_10: G = G::from_u64(100); + let __v_11: G = G::from_u64(132); + let __v_12: G = G::from_u64(157); + let __v_13: G = G::from_u64(213); + let __v_14: G = G::from_u64(119); + let __v_15: G = G::from_u64(192); + let __v_16: G = G::from_u64(102); + let __v_17: G = G::from_u64(229); + let __v_18: G = G::from_u64(97); + let __v_19: G = G::from_u64(66); + let __v_20: G = G::from_u64(32); + let __v_21: G = G::from_u64(111); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(188); + let __v_24: G = G::from_u64(114); + let __v_25: G = G::from_u64(78); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(141); + let __v_28: G = G::from_u64(182); + let __v_29: G = G::from_u64(242); + let __v_30: G = G::from_u64(15); + let __v_31: G = G::from_u64(91); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_154] = [__v_32]; if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17322,38 +17036,38 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(212); - let __v_1: G = G::from_u64(53); - let __v_2: G = G::from_u64(161); - let __v_3: G = G::from_u64(94); - let __v_4: G = G::from_u64(111); - let __v_5: G = G::from_u64(34); - let __v_6: G = G::from_u64(47); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(107); - let __v_9: G = G::from_u64(97); - let __v_10: G = G::from_u64(48); - let __v_11: G = G::from_u64(250); - let __v_12: G = G::from_u64(118); - let __v_13: G = G::from_u64(76); - let __v_14: G = G::from_u64(127); - let __v_15: G = G::from_u64(190); - let __v_16: G = G::from_u64(152); - let __v_17: G = G::from_u64(116); - let __v_18: G = G::from_u64(111); - let __v_19: G = G::from_u64(121); - let __v_20: G = G::from_u64(142); - let __v_21: G = G::from_u64(151); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(39); - let __v_24: G = G::from_u64(166); - let __v_25: G = G::from_u64(35); - let __v_26: G = G::from_u64(122); - let __v_27: G = G::from_u64(23); - let __v_28: G = G::from_u64(231); - let __v_29: G = G::from_u64(79); - let __v_30: G = G::from_u64(114); - let __v_31: G = G::from_u64(39); + let __v_0: G = G::from_u64(25); + let __v_1: G = G::from_u64(125); + let __v_2: G = G::from_u64(60); + let __v_3: G = G::from_u64(126); + let __v_4: G = G::from_u64(156); + let __v_5: G = G::from_u64(224); + let __v_6: G = G::from_u64(148); + let __v_7: G = G::from_u64(156); + let __v_8: G = G::from_u64(82); + let __v_9: G = G::from_u64(239); + let __v_10: G = G::from_u64(152); + let __v_11: G = G::from_u64(245); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(88); + let __v_14: G = G::from_u64(221); + let __v_15: G = G::from_u64(185); + let __v_16: G = G::from_u64(66); + let __v_17: G = G::from_u64(219); + let __v_18: G = G::from_u64(109); + let __v_19: G = G::from_u64(54); + let __v_20: G = G::from_u64(118); + let __v_21: G = G::from_u64(64); + let __v_22: G = G::from_u64(214); + let __v_23: G = G::from_u64(251); + let __v_24: G = G::from_u64(111); + let __v_25: G = G::from_u64(73); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(145); + let __v_28: G = G::from_u64(248); + let __v_29: G = G::from_u64(47); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_155] = [__v_32]; if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17371,38 +17085,38 @@ fn aiur_fn_156( unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(62); + let __v_0: G = G::from_u64(7); let __v_1: G = G::from_u64(19); - let __v_2: G = G::from_u64(252); - let __v_3: G = G::from_u64(26); - let __v_4: G = G::from_u64(7); - let __v_5: G = G::from_u64(126); - let __v_6: G = G::from_u64(182); - let __v_7: G = G::from_u64(146); - let __v_8: G = G::from_u64(175); - let __v_9: G = G::from_u64(64); - let __v_10: G = G::from_u64(172); - let __v_11: G = G::from_u64(190); - let __v_12: G = G::from_u64(212); - let __v_13: G = G::from_u64(166); - let __v_14: G = G::from_u64(173); - let __v_15: G = G::from_u64(174); - let __v_16: G = G::from_u64(37); - let __v_17: G = G::from_u64(92); - let __v_18: G = G::from_u64(12); - let __v_19: G = G::from_u64(187); - let __v_20: G = G::from_u64(186); - let __v_21: G = G::from_u64(154); - let __v_22: G = G::from_u64(60); - let __v_23: G = G::from_u64(31); - let __v_24: G = G::from_u64(13); - let __v_25: G = G::from_u64(226); - let __v_26: G = G::from_u64(149); - let __v_27: G = G::from_u64(115); - let __v_28: G = G::from_u64(177); - let __v_29: G = G::from_u64(151); - let __v_30: G = G::from_u64(203); - let __v_31: G = G::from_u64(14); + let __v_2: G = G::from_u64(64); + let __v_3: G = G::from_u64(90); + let __v_4: G = G::from_u64(104); + let __v_5: G = G::from_u64(157); + let __v_6: G = G::from_u64(33); + let __v_7: G = G::from_u64(85); + let __v_8: G = G::from_u64(168); + let __v_9: G = G::from_u64(65); + let __v_10: G = G::from_u64(35); + let __v_11: G = G::from_u64(160); + let __v_12: G = G::from_u64(246); + let __v_13: G = G::from_u64(57); + let __v_14: G = G::from_u64(92); + let __v_15: G = G::from_u64(49); + let __v_16: G = G::from_u64(198); + let __v_17: G = G::from_u64(250); + let __v_18: G = G::from_u64(85); + let __v_19: G = G::from_u64(193); + let __v_20: G = G::from_u64(173); + let __v_21: G = G::from_u64(144); + let __v_22: G = G::from_u64(95); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(86); + let __v_25: G = G::from_u64(99); + let __v_26: G = G::from_u64(172); + let __v_27: G = G::from_u64(247); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(87); + let __v_30: G = G::from_u64(127); + let __v_31: G = G::from_u64(87); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_156] = [__v_32]; if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17420,38 +17134,38 @@ fn aiur_fn_157( unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(153); - let __v_1: G = G::from_u64(112); - let __v_2: G = G::from_u64(244); - let __v_3: G = G::from_u64(2); - let __v_4: G = G::from_u64(200); - let __v_5: G = G::from_u64(112); - let __v_6: G = G::from_u64(232); - let __v_7: G = G::from_u64(163); - let __v_8: G = G::from_u64(20); - let __v_9: G = G::from_u64(111); - let __v_10: G = G::from_u64(191); - let __v_11: G = G::from_u64(75); - let __v_12: G = G::from_u64(118); - let __v_13: G = G::from_u64(249); - let __v_14: G = G::from_u64(73); - let __v_15: G = G::from_u64(170); - let __v_16: G = G::from_u64(100); - let __v_17: G = G::from_u64(178); - let __v_18: G = G::from_u64(6); - let __v_19: G = G::from_u64(222); - let __v_20: G = G::from_u64(155); - let __v_21: G = G::from_u64(1); - let __v_22: G = G::from_u64(87); - let __v_23: G = G::from_u64(180); - let __v_24: G = G::from_u64(105); - let __v_25: G = G::from_u64(253); - let __v_26: G = G::from_u64(227); - let __v_27: G = G::from_u64(87); - let __v_28: G = G::from_u64(183); - let __v_29: G = G::from_u64(21); - let __v_30: G = G::from_u64(241); - let __v_31: G = G::from_u64(156); + let __v_0: G = G::from_u64(131); + let __v_1: G = G::from_u64(227); + let __v_2: G = G::from_u64(206); + let __v_3: G = G::from_u64(138); + let __v_4: G = G::from_u64(116); + let __v_5: G = G::from_u64(117); + let __v_6: G = G::from_u64(32); + let __v_7: G = G::from_u64(204); + let __v_8: G = G::from_u64(36); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(13); + let __v_11: G = G::from_u64(172); + let __v_12: G = G::from_u64(249); + let __v_13: G = G::from_u64(189); + let __v_14: G = G::from_u64(19); + let __v_15: G = G::from_u64(105); + let __v_16: G = G::from_u64(70); + let __v_17: G = G::from_u64(126); + let __v_18: G = G::from_u64(73); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(232); + let __v_21: G = G::from_u64(170); + let __v_22: G = G::from_u64(170); + let __v_23: G = G::from_u64(67); + let __v_24: G = G::from_u64(62); + let __v_25: G = G::from_u64(27); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(142); + let __v_28: G = G::from_u64(28); + let __v_29: G = G::from_u64(173); + let __v_30: G = G::from_u64(124); + let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_157] = [__v_32]; if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17469,38 +17183,38 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(134); - let __v_1: G = G::from_u64(127); - let __v_2: G = G::from_u64(142); - let __v_3: G = G::from_u64(157); - let __v_4: G = G::from_u64(251); - let __v_5: G = G::from_u64(117); - let __v_6: G = G::from_u64(34); - let __v_7: G = G::from_u64(101); - let __v_8: G = G::from_u64(186); - let __v_9: G = G::from_u64(71); - let __v_10: G = G::from_u64(66); - let __v_11: G = G::from_u64(54); - let __v_12: G = G::from_u64(139); - let __v_13: G = G::from_u64(106); - let __v_14: G = G::from_u64(250); - let __v_15: G = G::from_u64(84); - let __v_16: G = G::from_u64(106); - let __v_17: G = G::from_u64(228); - let __v_18: G = G::from_u64(226); - let __v_19: G = G::from_u64(64); - let __v_20: G = G::from_u64(252); - let __v_21: G = G::from_u64(90); - let __v_22: G = G::from_u64(198); - let __v_23: G = G::from_u64(155); - let __v_24: G = G::from_u64(74); - let __v_25: G = G::from_u64(78); - let __v_26: G = G::from_u64(134); - let __v_27: G = G::from_u64(216); - let __v_28: G = G::from_u64(90); - let __v_29: G = G::from_u64(110); - let __v_30: G = G::from_u64(70); - let __v_31: G = G::from_u64(246); + let __v_0: G = G::from_u64(135); + let __v_1: G = G::from_u64(91); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(216); + let __v_4: G = G::from_u64(174); + let __v_5: G = G::from_u64(95); + let __v_6: G = G::from_u64(51); + let __v_7: G = G::from_u64(32); + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(236); + let __v_10: G = G::from_u64(43); + let __v_11: G = G::from_u64(173); + let __v_12: G = G::from_u64(230); + let __v_13: G = G::from_u64(152); + let __v_14: G = G::from_u64(187); + let __v_15: G = G::from_u64(10); + let __v_16: G = G::from_u64(165); + let __v_17: G = G::from_u64(242); + let __v_18: G = G::from_u64(244); + let __v_19: G = G::from_u64(110); + let __v_20: G = G::from_u64(113); + let __v_21: G = G::from_u64(33); + let __v_22: G = G::from_u64(141); + let __v_23: G = G::from_u64(169); + let __v_24: G = G::from_u64(205); + let __v_25: G = G::from_u64(217); + let __v_26: G = G::from_u64(208); + let __v_27: G = G::from_u64(149); + let __v_28: G = G::from_u64(6); + let __v_29: G = G::from_u64(232); + let __v_30: G = G::from_u64(76); + let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_32]; if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17518,38 +17232,38 @@ fn aiur_fn_159( unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(33); - let __v_1: G = G::from_u64(212); - let __v_2: G = G::from_u64(218); - let __v_3: G = G::from_u64(204); - let __v_4: G = G::from_u64(15); - let __v_5: G = G::from_u64(64); - let __v_6: G = G::from_u64(107); - let __v_7: G = G::from_u64(49); - let __v_8: G = G::from_u64(224); - let __v_9: G = G::from_u64(68); - let __v_10: G = G::from_u64(251); - let __v_11: G = G::from_u64(244); - let __v_12: G = G::from_u64(216); - let __v_13: G = G::from_u64(152); - let __v_14: G = G::from_u64(122); - let __v_15: G = G::from_u64(51); - let __v_16: G = G::from_u64(45); - let __v_17: G = G::from_u64(216); - let __v_18: G = G::from_u64(180); - let __v_19: G = G::from_u64(36); - let __v_20: G = G::from_u64(79); - let __v_21: G = G::from_u64(125); - let __v_22: G = G::from_u64(158); - let __v_23: G = G::from_u64(98); - let __v_24: G = G::from_u64(176); - let __v_25: G = G::from_u64(134); - let __v_26: G = G::from_u64(80); - let __v_27: G = G::from_u64(20); - let __v_28: G = G::from_u64(116); - let __v_29: G = G::from_u64(130); - let __v_30: G = G::from_u64(85); - let __v_31: G = G::from_u64(68); + let __v_0: G = G::from_u64(225); + let __v_1: G = G::from_u64(238); + let __v_2: G = G::from_u64(76); + let __v_3: G = G::from_u64(120); + let __v_4: G = G::from_u64(163); + let __v_5: G = G::from_u64(144); + let __v_6: G = G::from_u64(100); + let __v_7: G = G::from_u64(100); + let __v_8: G = G::from_u64(250); + let __v_9: G = G::from_u64(140); + let __v_10: G = G::from_u64(23); + let __v_11: G = G::from_u64(236); + let __v_12: G = G::from_u64(46); + let __v_13: G = G::from_u64(208); + let __v_14: G = G::from_u64(192); + let __v_15: G = G::from_u64(191); + let __v_16: G = G::from_u64(102); + let __v_17: G = G::from_u64(219); + let __v_18: G = G::from_u64(59); + let __v_19: G = G::from_u64(65); + let __v_20: G = G::from_u64(45); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(28); + let __v_23: G = G::from_u64(95); + let __v_24: G = G::from_u64(49); + let __v_25: G = G::from_u64(251); + let __v_26: G = G::from_u64(167); + let __v_27: G = G::from_u64(187); + let __v_28: G = G::from_u64(151); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(147); + let __v_31: G = G::from_u64(229); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_159] = [__v_32]; if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17567,38 +17281,38 @@ fn aiur_fn_160( unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(135); - let __v_1: G = G::from_u64(133); - let __v_2: G = G::from_u64(153); - let __v_3: G = G::from_u64(233); - let __v_4: G = G::from_u64(245); - let __v_5: G = G::from_u64(187); - let __v_6: G = G::from_u64(204); - let __v_7: G = G::from_u64(185); - let __v_8: G = G::from_u64(66); - let __v_9: G = G::from_u64(35); - let __v_10: G = G::from_u64(47); - let __v_11: G = G::from_u64(249); - let __v_12: G = G::from_u64(59); - let __v_13: G = G::from_u64(98); - let __v_14: G = G::from_u64(198); - let __v_15: G = G::from_u64(61); - let __v_16: G = G::from_u64(180); - let __v_17: G = G::from_u64(235); + let __v_0: G = G::from_u64(191); + let __v_1: G = G::from_u64(5); + let __v_2: G = G::from_u64(142); + let __v_3: G = G::from_u64(228); + let __v_4: G = G::from_u64(70); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(122); + let __v_7: G = G::from_u64(246); + let __v_8: G = G::from_u64(236); + let __v_9: G = G::from_u64(116); + let __v_10: G = G::from_u64(146); + let __v_11: G = G::from_u64(35); + let __v_12: G = G::from_u64(117); + let __v_13: G = G::from_u64(45); + let __v_14: G = G::from_u64(7); + let __v_15: G = G::from_u64(230); + let __v_16: G = G::from_u64(215); + let __v_17: G = G::from_u64(194); let __v_18: G = G::from_u64(223); - let __v_19: G = G::from_u64(98); - let __v_20: G = G::from_u64(185); - let __v_21: G = G::from_u64(249); - let __v_22: G = G::from_u64(35); - let __v_23: G = G::from_u64(121); - let __v_24: G = G::from_u64(0); - let __v_25: G = G::from_u64(163); - let __v_26: G = G::from_u64(112); - let __v_27: G = G::from_u64(73); - let __v_28: G = G::from_u64(244); - let __v_29: G = G::from_u64(34); - let __v_30: G = G::from_u64(173); - let __v_31: G = G::from_u64(134); + let __v_19: G = G::from_u64(141); + let __v_20: G = G::from_u64(192); + let __v_21: G = G::from_u64(160); + let __v_22: G = G::from_u64(119); + let __v_23: G = G::from_u64(141); + let __v_24: G = G::from_u64(147); + let __v_25: G = G::from_u64(79); + let __v_26: G = G::from_u64(136); + let __v_27: G = G::from_u64(90); + let __v_28: G = G::from_u64(232); + let __v_29: G = G::from_u64(38); + let __v_30: G = G::from_u64(125); + let __v_31: G = G::from_u64(87); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_160] = [__v_32]; if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17616,38 +17330,38 @@ fn aiur_fn_161( unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(249); - let __v_1: G = G::from_u64(172); - let __v_2: G = G::from_u64(146); - let __v_3: G = G::from_u64(161); - let __v_4: G = G::from_u64(19); - let __v_5: G = G::from_u64(136); - let __v_6: G = G::from_u64(167); - let __v_7: G = G::from_u64(205); - let __v_8: G = G::from_u64(202); - let __v_9: G = G::from_u64(34); - let __v_10: G = G::from_u64(154); - let __v_11: G = G::from_u64(128); - let __v_12: G = G::from_u64(36); - let __v_13: G = G::from_u64(32); - let __v_14: G = G::from_u64(133); - let __v_15: G = G::from_u64(84); - let __v_16: G = G::from_u64(254); - let __v_17: G = G::from_u64(179); - let __v_18: G = G::from_u64(45); - let __v_19: G = G::from_u64(108); - let __v_20: G = G::from_u64(10); - let __v_21: G = G::from_u64(58); - let __v_22: G = G::from_u64(247); - let __v_23: G = G::from_u64(74); - let __v_24: G = G::from_u64(123); - let __v_25: G = G::from_u64(193); - let __v_26: G = G::from_u64(44); - let __v_27: G = G::from_u64(40); - let __v_28: G = G::from_u64(185); - let __v_29: G = G::from_u64(73); - let __v_30: G = G::from_u64(84); - let __v_31: G = G::from_u64(60); + let __v_0: G = G::from_u64(194); + let __v_1: G = G::from_u64(254); + let __v_2: G = G::from_u64(94); + let __v_3: G = G::from_u64(218); + let __v_4: G = G::from_u64(30); + let __v_5: G = G::from_u64(85); + let __v_6: G = G::from_u64(146); + let __v_7: G = G::from_u64(54); + let __v_8: G = G::from_u64(191); + let __v_9: G = G::from_u64(194); + let __v_10: G = G::from_u64(167); + let __v_11: G = G::from_u64(164); + let __v_12: G = G::from_u64(125); + let __v_13: G = G::from_u64(176); + let __v_14: G = G::from_u64(202); + let __v_15: G = G::from_u64(108); + let __v_16: G = G::from_u64(247); + let __v_17: G = G::from_u64(130); + let __v_18: G = G::from_u64(247); + let __v_19: G = G::from_u64(182); + let __v_20: G = G::from_u64(155); + let __v_21: G = G::from_u64(221); + let __v_22: G = G::from_u64(150); + let __v_23: G = G::from_u64(50); + let __v_24: G = G::from_u64(55); + let __v_25: G = G::from_u64(208); + let __v_26: G = G::from_u64(136); + let __v_27: G = G::from_u64(159); + let __v_28: G = G::from_u64(191); + let __v_29: G = G::from_u64(154); + let __v_30: G = G::from_u64(75); + let __v_31: G = G::from_u64(7); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_161] = [__v_32]; if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17665,38 +17379,38 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(223); - let __v_1: G = G::from_u64(56); - let __v_2: G = G::from_u64(53); - let __v_3: G = G::from_u64(47); - let __v_4: G = G::from_u64(250); - let __v_5: G = G::from_u64(29); - let __v_6: G = G::from_u64(110); - let __v_7: G = G::from_u64(41); - let __v_8: G = G::from_u64(35); - let __v_9: G = G::from_u64(73); - let __v_10: G = G::from_u64(37); - let __v_11: G = G::from_u64(159); - let __v_12: G = G::from_u64(51); - let __v_13: G = G::from_u64(235); - let __v_14: G = G::from_u64(103); - let __v_15: G = G::from_u64(128); - let __v_16: G = G::from_u64(36); - let __v_17: G = G::from_u64(187); - let __v_18: G = G::from_u64(100); - let __v_19: G = G::from_u64(107); - let __v_20: G = G::from_u64(53); - let __v_21: G = G::from_u64(134); - let __v_22: G = G::from_u64(56); - let __v_23: G = G::from_u64(160); - let __v_24: G = G::from_u64(45); - let __v_25: G = G::from_u64(161); - let __v_26: G = G::from_u64(153); - let __v_27: G = G::from_u64(94); - let __v_28: G = G::from_u64(212); - let __v_29: G = G::from_u64(171); - let __v_30: G = G::from_u64(235); - let __v_31: G = G::from_u64(9); + let __v_0: G = G::from_u64(10); + let __v_1: G = G::from_u64(236); + let __v_2: G = G::from_u64(146); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(62); + let __v_5: G = G::from_u64(89); + let __v_6: G = G::from_u64(141); + let __v_7: G = G::from_u64(95); + let __v_8: G = G::from_u64(203); + let __v_9: G = G::from_u64(93); + let __v_10: G = G::from_u64(207); + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(57); + let __v_14: G = G::from_u64(156); + let __v_15: G = G::from_u64(105); + let __v_16: G = G::from_u64(235); + let __v_17: G = G::from_u64(246); + let __v_18: G = G::from_u64(164); + let __v_19: G = G::from_u64(59); + let __v_20: G = G::from_u64(158); + let __v_21: G = G::from_u64(233); + let __v_22: G = G::from_u64(122); + let __v_23: G = G::from_u64(62); + let __v_24: G = G::from_u64(86); + let __v_25: G = G::from_u64(20); + let __v_26: G = G::from_u64(54); + let __v_27: G = G::from_u64(185); + let __v_28: G = G::from_u64(242); + let __v_29: G = G::from_u64(185); + let __v_30: G = G::from_u64(84); + let __v_31: G = G::from_u64(128); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_162] = [__v_32]; if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17714,38 +17428,38 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(243); - let __v_1: G = G::from_u64(141); - let __v_2: G = G::from_u64(79); - let __v_3: G = G::from_u64(123); - let __v_4: G = G::from_u64(170); - let __v_5: G = G::from_u64(160); - let __v_6: G = G::from_u64(33); - let __v_7: G = G::from_u64(227); - let __v_8: G = G::from_u64(181); - let __v_9: G = G::from_u64(85); - let __v_10: G = G::from_u64(49); - let __v_11: G = G::from_u64(33); - let __v_12: G = G::from_u64(69); - let __v_13: G = G::from_u64(217); + let __v_0: G = G::from_u64(89); + let __v_1: G = G::from_u64(228); + let __v_2: G = G::from_u64(125); + let __v_3: G = G::from_u64(113); + let __v_4: G = G::from_u64(215); + let __v_5: G = G::from_u64(60); + let __v_6: G = G::from_u64(84); + let __v_7: G = G::from_u64(78); + let __v_8: G = G::from_u64(225); + let __v_9: G = G::from_u64(164); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(240); + let __v_12: G = G::from_u64(126); + let __v_13: G = G::from_u64(159); let __v_14: G = G::from_u64(255); - let __v_15: G = G::from_u64(211); - let __v_16: G = G::from_u64(221); - let __v_17: G = G::from_u64(197); - let __v_18: G = G::from_u64(234); - let __v_19: G = G::from_u64(203); - let __v_20: G = G::from_u64(123); - let __v_21: G = G::from_u64(253); - let __v_22: G = G::from_u64(91); - let __v_23: G = G::from_u64(134); - let __v_24: G = G::from_u64(167); - let __v_25: G = G::from_u64(176); - let __v_26: G = G::from_u64(234); - let __v_27: G = G::from_u64(253); - let __v_28: G = G::from_u64(252); - let __v_29: G = G::from_u64(244); - let __v_30: G = G::from_u64(22); - let __v_31: G = G::from_u64(170); + let __v_15: G = G::from_u64(245); + let __v_16: G = G::from_u64(66); + let __v_17: G = G::from_u64(203); + let __v_18: G = G::from_u64(117); + let __v_19: G = G::from_u64(126); + let __v_20: G = G::from_u64(115); + let __v_21: G = G::from_u64(150); + let __v_22: G = G::from_u64(81); + let __v_23: G = G::from_u64(169); + let __v_24: G = G::from_u64(205); + let __v_25: G = G::from_u64(69); + let __v_26: G = G::from_u64(58); + let __v_27: G = G::from_u64(240); + let __v_28: G = G::from_u64(61); + let __v_29: G = G::from_u64(61); + let __v_30: G = G::from_u64(206); + let __v_31: G = G::from_u64(66); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_163] = [__v_32]; if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17763,38 +17477,38 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(104); - let __v_1: G = G::from_u64(246); - let __v_2: G = G::from_u64(30); - let __v_3: G = G::from_u64(245); - let __v_4: G = G::from_u64(91); - let __v_5: G = G::from_u64(99); - let __v_6: G = G::from_u64(205); - let __v_7: G = G::from_u64(35); - let __v_8: G = G::from_u64(173); - let __v_9: G = G::from_u64(142); - let __v_10: G = G::from_u64(209); - let __v_11: G = G::from_u64(133); - let __v_12: G = G::from_u64(183); - let __v_13: G = G::from_u64(238); - let __v_14: G = G::from_u64(195); - let __v_15: G = G::from_u64(220); - let __v_16: G = G::from_u64(117); - let __v_17: G = G::from_u64(78); - let __v_18: G = G::from_u64(97); - let __v_19: G = G::from_u64(204); - let __v_20: G = G::from_u64(88); - let __v_21: G = G::from_u64(5); - let __v_22: G = G::from_u64(96); - let __v_23: G = G::from_u64(135); - let __v_24: G = G::from_u64(169); - let __v_25: G = G::from_u64(126); - let __v_26: G = G::from_u64(129); - let __v_27: G = G::from_u64(157); - let __v_28: G = G::from_u64(14); - let __v_29: G = G::from_u64(149); - let __v_30: G = G::from_u64(230); - let __v_31: G = G::from_u64(253); + let __v_0: G = G::from_u64(44); + let __v_1: G = G::from_u64(157); + let __v_2: G = G::from_u64(45); + let __v_3: G = G::from_u64(62); + let __v_4: G = G::from_u64(126); + let __v_5: G = G::from_u64(151); + let __v_6: G = G::from_u64(75); + let __v_7: G = G::from_u64(67); + let __v_8: G = G::from_u64(202); + let __v_9: G = G::from_u64(61); + let __v_10: G = G::from_u64(33); + let __v_11: G = G::from_u64(47); + let __v_12: G = G::from_u64(50); + let __v_13: G = G::from_u64(112); + let __v_14: G = G::from_u64(113); + let __v_15: G = G::from_u64(135); + let __v_16: G = G::from_u64(56); + let __v_17: G = G::from_u64(33); + let __v_18: G = G::from_u64(37); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(39); + let __v_21: G = G::from_u64(39); + let __v_22: G = G::from_u64(88); + let __v_23: G = G::from_u64(246); + let __v_24: G = G::from_u64(156); + let __v_25: G = G::from_u64(75); + let __v_26: G = G::from_u64(71); + let __v_27: G = G::from_u64(233); + let __v_28: G = G::from_u64(109); + let __v_29: G = G::from_u64(154); + let __v_30: G = G::from_u64(171); + let __v_31: G = G::from_u64(207); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_164] = [__v_32]; if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17812,38 +17526,38 @@ fn aiur_fn_165( unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(173); - let __v_1: G = G::from_u64(71); - let __v_2: G = G::from_u64(242); - let __v_3: G = G::from_u64(187); - let __v_4: G = G::from_u64(232); - let __v_5: G = G::from_u64(145); - let __v_6: G = G::from_u64(184); - let __v_7: G = G::from_u64(37); - let __v_8: G = G::from_u64(196); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(39); - let __v_11: G = G::from_u64(143); - let __v_12: G = G::from_u64(154); - let __v_13: G = G::from_u64(13); - let __v_14: G = G::from_u64(114); - let __v_15: G = G::from_u64(153); - let __v_16: G = G::from_u64(123); - let __v_17: G = G::from_u64(120); - let __v_18: G = G::from_u64(186); - let __v_19: G = G::from_u64(172); - let __v_20: G = G::from_u64(121); - let __v_21: G = G::from_u64(137); - let __v_22: G = G::from_u64(28); - let __v_23: G = G::from_u64(166); - let __v_24: G = G::from_u64(101); - let __v_25: G = G::from_u64(25); - let __v_26: G = G::from_u64(136); - let __v_27: G = G::from_u64(183); - let __v_28: G = G::from_u64(201); - let __v_29: G = G::from_u64(180); - let __v_30: G = G::from_u64(127); - let __v_31: G = G::from_u64(3); + let __v_0: G = G::from_u64(47); + let __v_1: G = G::from_u64(18); + let __v_2: G = G::from_u64(243); + let __v_3: G = G::from_u64(34); + let __v_4: G = G::from_u64(148); + let __v_5: G = G::from_u64(183); + let __v_6: G = G::from_u64(209); + let __v_7: G = G::from_u64(22); + let __v_8: G = G::from_u64(138); + let __v_9: G = G::from_u64(218); + let __v_10: G = G::from_u64(24); + let __v_11: G = G::from_u64(9); + let __v_12: G = G::from_u64(201); + let __v_13: G = G::from_u64(184); + let __v_14: G = G::from_u64(178); + let __v_15: G = G::from_u64(86); + let __v_16: G = G::from_u64(56); + let __v_17: G = G::from_u64(36); + let __v_18: G = G::from_u64(233); + let __v_19: G = G::from_u64(194); + let __v_20: G = G::from_u64(135); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(248); + let __v_23: G = G::from_u64(211); + let __v_24: G = G::from_u64(187); + let __v_25: G = G::from_u64(155); + let __v_26: G = G::from_u64(92); + let __v_27: G = G::from_u64(3); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(171); + let __v_30: G = G::from_u64(113); + let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_165] = [__v_32]; if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17861,38 +17575,38 @@ fn aiur_fn_166( unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(246); - let __v_1: G = G::from_u64(235); - let __v_2: G = G::from_u64(116); - let __v_3: G = G::from_u64(41); - let __v_4: G = G::from_u64(150); - let __v_5: G = G::from_u64(198); - let __v_6: G = G::from_u64(15); - let __v_7: G = G::from_u64(16); - let __v_8: G = G::from_u64(104); - let __v_9: G = G::from_u64(194); - let __v_10: G = G::from_u64(212); - let __v_11: G = G::from_u64(55); - let __v_12: G = G::from_u64(175); - let __v_13: G = G::from_u64(221); - let __v_14: G = G::from_u64(139); - let __v_15: G = G::from_u64(54); - let __v_16: G = G::from_u64(9); - let __v_17: G = G::from_u64(4); - let __v_18: G = G::from_u64(13); - let __v_19: G = G::from_u64(100); - let __v_20: G = G::from_u64(238); - let __v_21: G = G::from_u64(197); - let __v_22: G = G::from_u64(225); - let __v_23: G = G::from_u64(95); - let __v_24: G = G::from_u64(7); - let __v_25: G = G::from_u64(161); - let __v_26: G = G::from_u64(29); - let __v_27: G = G::from_u64(193); - let __v_28: G = G::from_u64(29); - let __v_29: G = G::from_u64(7); - let __v_30: G = G::from_u64(13); - let __v_31: G = G::from_u64(123); + let __v_0: G = G::from_u64(131); + let __v_1: G = G::from_u64(60); + let __v_2: G = G::from_u64(91); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(60); + let __v_5: G = G::from_u64(7); + let __v_6: G = G::from_u64(126); + let __v_7: G = G::from_u64(182); + let __v_8: G = G::from_u64(179); + let __v_9: G = G::from_u64(192); + let __v_10: G = G::from_u64(228); + let __v_11: G = G::from_u64(216); + let __v_12: G = G::from_u64(72); + let __v_13: G = G::from_u64(207); + let __v_14: G = G::from_u64(84); + let __v_15: G = G::from_u64(8); + let __v_16: G = G::from_u64(36); + let __v_17: G = G::from_u64(12); + let __v_18: G = G::from_u64(125); + let __v_19: G = G::from_u64(60); + let __v_20: G = G::from_u64(255); + let __v_21: G = G::from_u64(140); + let __v_22: G = G::from_u64(64); + let __v_23: G = G::from_u64(99); + let __v_24: G = G::from_u64(92); + let __v_25: G = G::from_u64(110); + let __v_26: G = G::from_u64(59); + let __v_27: G = G::from_u64(249); + let __v_28: G = G::from_u64(70); + let __v_29: G = G::from_u64(99); + let __v_30: G = G::from_u64(14); + let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_166] = [__v_32]; if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17910,38 +17624,38 @@ fn aiur_fn_167( unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(35); - let __v_1: G = G::from_u64(23); - let __v_2: G = G::from_u64(54); - let __v_3: G = G::from_u64(73); - let __v_4: G = G::from_u64(165); - let __v_5: G = G::from_u64(142); - let __v_6: G = G::from_u64(165); - let __v_7: G = G::from_u64(9); - let __v_8: G = G::from_u64(93); - let __v_9: G = G::from_u64(28); - let __v_10: G = G::from_u64(81); - let __v_11: G = G::from_u64(162); - let __v_12: G = G::from_u64(28); - let __v_13: G = G::from_u64(122); - let __v_14: G = G::from_u64(210); - let __v_15: G = G::from_u64(207); - let __v_16: G = G::from_u64(142); - let __v_17: G = G::from_u64(141); - let __v_18: G = G::from_u64(204); - let __v_19: G = G::from_u64(239); - let __v_20: G = G::from_u64(52); - let __v_21: G = G::from_u64(38); - let __v_22: G = G::from_u64(152); - let __v_23: G = G::from_u64(224); - let __v_24: G = G::from_u64(126); - let __v_25: G = G::from_u64(36); - let __v_26: G = G::from_u64(22); - let __v_27: G = G::from_u64(104); - let __v_28: G = G::from_u64(255); - let __v_29: G = G::from_u64(122); - let __v_30: G = G::from_u64(211); - let __v_31: G = G::from_u64(231); + let __v_0: G = G::from_u64(114); + let __v_1: G = G::from_u64(50); + let __v_2: G = G::from_u64(9); + let __v_3: G = G::from_u64(90); + let __v_4: G = G::from_u64(234); + let __v_5: G = G::from_u64(154); + let __v_6: G = G::from_u64(95); + let __v_7: G = G::from_u64(121); + let __v_8: G = G::from_u64(204); + let __v_9: G = G::from_u64(15); + let __v_10: G = G::from_u64(43); + let __v_11: G = G::from_u64(10); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(72); + let __v_14: G = G::from_u64(219); + let __v_15: G = G::from_u64(241); + let __v_16: G = G::from_u64(144); + let __v_17: G = G::from_u64(74); + let __v_18: G = G::from_u64(99); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(30); + let __v_21: G = G::from_u64(248); + let __v_22: G = G::from_u64(111); + let __v_23: G = G::from_u64(36); + let __v_24: G = G::from_u64(79); + let __v_25: G = G::from_u64(138); + let __v_26: G = G::from_u64(66); + let __v_27: G = G::from_u64(184); + let __v_28: G = G::from_u64(71); + let __v_29: G = G::from_u64(175); + let __v_30: G = G::from_u64(171); + let __v_31: G = G::from_u64(154); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_167] = [__v_32]; if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17959,38 +17673,38 @@ fn aiur_fn_168( unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(143); - let __v_1: G = G::from_u64(71); - let __v_2: G = G::from_u64(92); - let __v_3: G = G::from_u64(199); - let __v_4: G = G::from_u64(45); - let __v_5: G = G::from_u64(162); - let __v_6: G = G::from_u64(172); - let __v_7: G = G::from_u64(108); - let __v_8: G = G::from_u64(226); - let __v_9: G = G::from_u64(169); - let __v_10: G = G::from_u64(40); - let __v_11: G = G::from_u64(43); - let __v_12: G = G::from_u64(107); - let __v_13: G = G::from_u64(93); - let __v_14: G = G::from_u64(244); - let __v_15: G = G::from_u64(204); - let __v_16: G = G::from_u64(247); - let __v_17: G = G::from_u64(188); - let __v_18: G = G::from_u64(60); - let __v_19: G = G::from_u64(238); - let __v_20: G = G::from_u64(6); - let __v_21: G = G::from_u64(73); - let __v_22: G = G::from_u64(210); - let __v_23: G = G::from_u64(39); - let __v_24: G = G::from_u64(102); - let __v_25: G = G::from_u64(190); - let __v_26: G = G::from_u64(189); - let __v_27: G = G::from_u64(50); - let __v_28: G = G::from_u64(209); - let __v_29: G = G::from_u64(128); - let __v_30: G = G::from_u64(111); - let __v_31: G = G::from_u64(59); + let __v_0: G = G::from_u64(195); + let __v_1: G = G::from_u64(176); + let __v_2: G = G::from_u64(11); + let __v_3: G = G::from_u64(81); + let __v_4: G = G::from_u64(75); + let __v_5: G = G::from_u64(159); + let __v_6: G = G::from_u64(38); + let __v_7: G = G::from_u64(220); + let __v_8: G = G::from_u64(30); + let __v_9: G = G::from_u64(223); + let __v_10: G = G::from_u64(16); + let __v_11: G = G::from_u64(199); + let __v_12: G = G::from_u64(214); + let __v_13: G = G::from_u64(246); + let __v_14: G = G::from_u64(159); + let __v_15: G = G::from_u64(69); + let __v_16: G = G::from_u64(94); + let __v_17: G = G::from_u64(248); + let __v_18: G = G::from_u64(237); + let __v_19: G = G::from_u64(12); + let __v_20: G = G::from_u64(81); + let __v_21: G = G::from_u64(176); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(102); + let __v_24: G = G::from_u64(227); + let __v_25: G = G::from_u64(66); + let __v_26: G = G::from_u64(127); + let __v_27: G = G::from_u64(180); + let __v_28: G = G::from_u64(77); + let __v_29: G = G::from_u64(58); + let __v_30: G = G::from_u64(4); + let __v_31: G = G::from_u64(240); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_168] = [__v_32]; if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18008,38 +17722,38 @@ fn aiur_fn_169( unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(143); - let __v_1: G = G::from_u64(60); - let __v_2: G = G::from_u64(28); - let __v_3: G = G::from_u64(67); - let __v_4: G = G::from_u64(44); - let __v_5: G = G::from_u64(89); - let __v_6: G = G::from_u64(142); - let __v_7: G = G::from_u64(66); - let __v_8: G = G::from_u64(64); - let __v_9: G = G::from_u64(211); - let __v_10: G = G::from_u64(111); - let __v_11: G = G::from_u64(137); - let __v_12: G = G::from_u64(69); - let __v_13: G = G::from_u64(148); - let __v_14: G = G::from_u64(33); - let __v_15: G = G::from_u64(116); - let __v_16: G = G::from_u64(103); - let __v_17: G = G::from_u64(92); - let __v_18: G = G::from_u64(92); - let __v_19: G = G::from_u64(145); - let __v_20: G = G::from_u64(224); - let __v_21: G = G::from_u64(63); - let __v_22: G = G::from_u64(107); - let __v_23: G = G::from_u64(138); - let __v_24: G = G::from_u64(176); - let __v_25: G = G::from_u64(24); - let __v_26: G = G::from_u64(232); - let __v_27: G = G::from_u64(176); - let __v_28: G = G::from_u64(82); - let __v_29: G = G::from_u64(98); - let __v_30: G = G::from_u64(44); - let __v_31: G = G::from_u64(99); + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(112); + let __v_2: G = G::from_u64(205); + let __v_3: G = G::from_u64(157); + let __v_4: G = G::from_u64(23); + let __v_5: G = G::from_u64(8); + let __v_6: G = G::from_u64(184); + let __v_7: G = G::from_u64(240); + let __v_8: G = G::from_u64(11); + let __v_9: G = G::from_u64(228); + let __v_10: G = G::from_u64(96); + let __v_11: G = G::from_u64(101); + let __v_12: G = G::from_u64(92); + let __v_13: G = G::from_u64(164); + let __v_14: G = G::from_u64(122); + let __v_15: G = G::from_u64(65); + let __v_16: G = G::from_u64(157); + let __v_17: G = G::from_u64(198); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(249); + let __v_20: G = G::from_u64(192); + let __v_21: G = G::from_u64(85); + let __v_22: G = G::from_u64(142); + let __v_23: G = G::from_u64(122); + let __v_24: G = G::from_u64(194); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(184); + let __v_27: G = G::from_u64(14); + let __v_28: G = G::from_u64(230); + let __v_29: G = G::from_u64(255); + let __v_30: G = G::from_u64(9); + let __v_31: G = G::from_u64(120); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_169] = [__v_32]; if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18057,38 +17771,38 @@ fn aiur_fn_170( unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(128); - let __v_1: G = G::from_u64(10); - let __v_2: G = G::from_u64(138); - let __v_3: G = G::from_u64(45); - let __v_4: G = G::from_u64(111); - let __v_5: G = G::from_u64(145); - let __v_6: G = G::from_u64(189); - let __v_7: G = G::from_u64(26); - let __v_8: G = G::from_u64(145); - let __v_9: G = G::from_u64(211); - let __v_10: G = G::from_u64(19); - let __v_11: G = G::from_u64(209); - let __v_12: G = G::from_u64(225); - let __v_13: G = G::from_u64(158); - let __v_14: G = G::from_u64(246); - let __v_15: G = G::from_u64(159); - let __v_16: G = G::from_u64(55); - let __v_17: G = G::from_u64(222); - let __v_18: G = G::from_u64(221); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(247); - let __v_21: G = G::from_u64(222); - let __v_22: G = G::from_u64(79); - let __v_23: G = G::from_u64(146); - let __v_24: G = G::from_u64(151); - let __v_25: G = G::from_u64(128); - let __v_26: G = G::from_u64(190); - let __v_27: G = G::from_u64(133); - let __v_28: G = G::from_u64(90); - let __v_29: G = G::from_u64(3); - let __v_30: G = G::from_u64(253); - let __v_31: G = G::from_u64(31); + let __v_0: G = G::from_u64(216); + let __v_1: G = G::from_u64(221); + let __v_2: G = G::from_u64(236); + let __v_3: G = G::from_u64(103); + let __v_4: G = G::from_u64(211); + let __v_5: G = G::from_u64(46); + let __v_6: G = G::from_u64(235); + let __v_7: G = G::from_u64(31); + let __v_8: G = G::from_u64(43); + let __v_9: G = G::from_u64(13); + let __v_10: G = G::from_u64(84); + let __v_11: G = G::from_u64(3); + let __v_12: G = G::from_u64(114); + let __v_13: G = G::from_u64(237); + let __v_14: G = G::from_u64(116); + let __v_15: G = G::from_u64(82); + let __v_16: G = G::from_u64(32); + let __v_17: G = G::from_u64(253); + let __v_18: G = G::from_u64(177); + let __v_19: G = G::from_u64(228); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(178); + let __v_22: G = G::from_u64(245); + let __v_23: G = G::from_u64(75); + let __v_24: G = G::from_u64(173); + let __v_25: G = G::from_u64(222); + let __v_26: G = G::from_u64(96); + let __v_27: G = G::from_u64(182); + let __v_28: G = G::from_u64(103); + let __v_29: G = G::from_u64(52); + let __v_30: G = G::from_u64(249); + let __v_31: G = G::from_u64(243); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_170] = [__v_32]; if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18106,38 +17820,38 @@ fn aiur_fn_171( unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(84); - let __v_1: G = G::from_u64(115); - let __v_2: G = G::from_u64(89); - let __v_3: G = G::from_u64(46); - let __v_4: G = G::from_u64(112); - let __v_5: G = G::from_u64(121); - let __v_6: G = G::from_u64(67); - let __v_7: G = G::from_u64(236); - let __v_8: G = G::from_u64(7); - let __v_9: G = G::from_u64(42); - let __v_10: G = G::from_u64(46); - let __v_11: G = G::from_u64(229); - let __v_12: G = G::from_u64(60); - let __v_13: G = G::from_u64(67); - let __v_14: G = G::from_u64(61); - let __v_15: G = G::from_u64(162); - let __v_16: G = G::from_u64(199); - let __v_17: G = G::from_u64(122); - let __v_18: G = G::from_u64(164); - let __v_19: G = G::from_u64(94); - let __v_20: G = G::from_u64(214); - let __v_21: G = G::from_u64(52); - let __v_22: G = G::from_u64(218); - let __v_23: G = G::from_u64(84); - let __v_24: G = G::from_u64(178); - let __v_25: G = G::from_u64(67); - let __v_26: G = G::from_u64(116); - let __v_27: G = G::from_u64(209); - let __v_28: G = G::from_u64(158); - let __v_29: G = G::from_u64(185); - let __v_30: G = G::from_u64(12); - let __v_31: G = G::from_u64(210); + let __v_0: G = G::from_u64(202); + let __v_1: G = G::from_u64(48); + let __v_2: G = G::from_u64(34); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(53); + let __v_6: G = G::from_u64(155); + let __v_7: G = G::from_u64(12); + let __v_8: G = G::from_u64(67); + let __v_9: G = G::from_u64(94); + let __v_10: G = G::from_u64(180); + let __v_11: G = G::from_u64(187); + let __v_12: G = G::from_u64(142); + let __v_13: G = G::from_u64(142); + let __v_14: G = G::from_u64(172); + let __v_15: G = G::from_u64(10); + let __v_16: G = G::from_u64(160); + let __v_17: G = G::from_u64(133); + let __v_18: G = G::from_u64(209); + let __v_19: G = G::from_u64(218); + let __v_20: G = G::from_u64(16); + let __v_21: G = G::from_u64(242); + let __v_22: G = G::from_u64(89); + let __v_23: G = G::from_u64(40); + let __v_24: G = G::from_u64(112); + let __v_25: G = G::from_u64(37); + let __v_26: G = G::from_u64(34); + let __v_27: G = G::from_u64(152); + let __v_28: G = G::from_u64(97); + let __v_29: G = G::from_u64(17); + let __v_30: G = G::from_u64(32); + let __v_31: G = G::from_u64(112); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_171] = [__v_32]; if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18155,38 +17869,38 @@ fn aiur_fn_172( unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(27); - let __v_1: G = G::from_u64(89); - let __v_2: G = G::from_u64(17); - let __v_3: G = G::from_u64(73); - let __v_4: G = G::from_u64(21); - let __v_5: G = G::from_u64(141); - let __v_6: G = G::from_u64(137); - let __v_7: G = G::from_u64(105); - let __v_8: G = G::from_u64(55); - let __v_9: G = G::from_u64(238); - let __v_10: G = G::from_u64(191); - let __v_11: G = G::from_u64(213); - let __v_12: G = G::from_u64(50); - let __v_13: G = G::from_u64(50); - let __v_14: G = G::from_u64(181); - let __v_15: G = G::from_u64(174); - let __v_16: G = G::from_u64(138); - let __v_17: G = G::from_u64(75); - let __v_18: G = G::from_u64(205); - let __v_19: G = G::from_u64(178); - let __v_20: G = G::from_u64(90); - let __v_21: G = G::from_u64(104); - let __v_22: G = G::from_u64(17); - let __v_23: G = G::from_u64(201); - let __v_24: G = G::from_u64(107); - let __v_25: G = G::from_u64(217); - let __v_26: G = G::from_u64(65); - let __v_27: G = G::from_u64(20); - let __v_28: G = G::from_u64(169); - let __v_29: G = G::from_u64(248); - let __v_30: G = G::from_u64(190); - let __v_31: G = G::from_u64(213); + let __v_0: G = G::from_u64(202); + let __v_1: G = G::from_u64(75); + let __v_2: G = G::from_u64(57); + let __v_3: G = G::from_u64(139); + let __v_4: G = G::from_u64(32); + let __v_5: G = G::from_u64(128); + let __v_6: G = G::from_u64(190); + let __v_7: G = G::from_u64(204); + let __v_8: G = G::from_u64(204); + let __v_9: G = G::from_u64(243); + let __v_10: G = G::from_u64(163); + let __v_11: G = G::from_u64(18); + let __v_12: G = G::from_u64(30); + let __v_13: G = G::from_u64(132); + let __v_14: G = G::from_u64(139); + let __v_15: G = G::from_u64(209); + let __v_16: G = G::from_u64(151); + let __v_17: G = G::from_u64(120); + let __v_18: G = G::from_u64(71); + let __v_19: G = G::from_u64(102); + let __v_20: G = G::from_u64(140); + let __v_21: G = G::from_u64(24); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(68); + let __v_24: G = G::from_u64(123); + let __v_25: G = G::from_u64(14); + let __v_26: G = G::from_u64(220); + let __v_27: G = G::from_u64(95); + let __v_28: G = G::from_u64(86); + let __v_29: G = G::from_u64(27); + let __v_30: G = G::from_u64(28); + let __v_31: G = G::from_u64(188); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_32]; if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18203,104 +17917,6 @@ fn aiur_fn_173( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(114); - let __v_1: G = G::from_u64(198); - let __v_2: G = G::from_u64(212); - let __v_3: G = G::from_u64(163); - let __v_4: G = G::from_u64(182); - let __v_5: G = G::from_u64(83); - let __v_6: G = G::from_u64(121); - let __v_7: G = G::from_u64(136); - let __v_8: G = G::from_u64(80); - let __v_9: G = G::from_u64(169); - let __v_10: G = G::from_u64(237); - let __v_11: G = G::from_u64(87); - let __v_12: G = G::from_u64(1); - let __v_13: G = G::from_u64(139); - let __v_14: G = G::from_u64(135); - let __v_15: G = G::from_u64(206); - let __v_16: G = G::from_u64(238); - let __v_17: G = G::from_u64(14); - let __v_18: G = G::from_u64(52); - let __v_19: G = G::from_u64(25); - let __v_20: G = G::from_u64(92); - let __v_21: G = G::from_u64(9); - let __v_22: G = G::from_u64(2); - let __v_23: G = G::from_u64(133); - let __v_24: G = G::from_u64(143); - let __v_25: G = G::from_u64(212); - let __v_26: G = G::from_u64(31); - let __v_27: G = G::from_u64(111); - let __v_28: G = G::from_u64(14); - let __v_29: G = G::from_u64(153); - let __v_30: G = G::from_u64(98); - let __v_31: G = G::from_u64(174); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_173] = [__v_32]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_174: usize = 0; -const IN_174: usize = 0; -const OUT_174: usize = 1; -fn aiur_fn_174( - inp: [G; IN_174], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(195); - let __v_1: G = G::from_u64(127); - let __v_2: G = G::from_u64(46); - let __v_3: G = G::from_u64(129); - let __v_4: G = G::from_u64(31); - let __v_5: G = G::from_u64(68); - let __v_6: G = G::from_u64(213); - let __v_7: G = G::from_u64(156); - let __v_8: G = G::from_u64(7); - let __v_9: G = G::from_u64(9); - let __v_10: G = G::from_u64(73); - let __v_11: G = G::from_u64(71); - let __v_12: G = G::from_u64(20); - let __v_13: G = G::from_u64(111); - let __v_14: G = G::from_u64(252); - let __v_15: G = G::from_u64(189); - let __v_16: G = G::from_u64(58); - let __v_17: G = G::from_u64(236); - let __v_18: G = G::from_u64(94); - let __v_19: G = G::from_u64(199); - let __v_20: G = G::from_u64(0); - let __v_21: G = G::from_u64(42); - let __v_22: G = G::from_u64(195); - let __v_23: G = G::from_u64(196); - let __v_24: G = G::from_u64(142); - let __v_25: G = G::from_u64(189); - let __v_26: G = G::from_u64(235); - let __v_27: G = G::from_u64(205); - let __v_28: G = G::from_u64(131); - let __v_29: G = G::from_u64(212); - let __v_30: G = G::from_u64(104); - let __v_31: G = G::from_u64(142); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_174] = [__v_32]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_175: usize = 0; -const IN_175: usize = 0; -const OUT_175: usize = 1; -fn aiur_fn_175( - inp: [G; IN_175], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); @@ -18335,21 +17951,21 @@ fn aiur_fn_175( 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_175] = [__v_32]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_32]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 0; -const IN_176: usize = 0; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_174: usize = 0; +const IN_174: usize = 0; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); @@ -18384,6 +18000,104 @@ fn aiur_fn_176( 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_174] = [__v_32]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_175: usize = 0; +const IN_175: usize = 0; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_175], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(169); + let __v_1: G = G::from_u64(22); + let __v_2: G = G::from_u64(36); + let __v_3: G = G::from_u64(68); + let __v_4: G = G::from_u64(83); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(166); + let __v_7: G = G::from_u64(116); + let __v_8: G = G::from_u64(250); + let __v_9: G = G::from_u64(15); + let __v_10: G = G::from_u64(158); + let __v_11: G = G::from_u64(159); + let __v_12: G = G::from_u64(154); + let __v_13: G = G::from_u64(82); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(27); + let __v_16: G = G::from_u64(147); + let __v_17: G = G::from_u64(177); + let __v_18: G = G::from_u64(4); + let __v_19: G = G::from_u64(135); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(128); + let __v_22: G = G::from_u64(70); + let __v_23: G = G::from_u64(203); + let __v_24: G = G::from_u64(193); + let __v_25: G = G::from_u64(38); + let __v_26: G = G::from_u64(90); + let __v_27: G = G::from_u64(36); + let __v_28: G = G::from_u64(85); + let __v_29: G = G::from_u64(188); + let __v_30: G = G::from_u64(250); + let __v_31: G = G::from_u64(236); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_175] = [__v_32]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_176: usize = 0; +const IN_176: usize = 0; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_176], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(123); + let __v_1: G = G::from_u64(216); + 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_176] = [__v_32]; if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); @@ -18400,38 +18114,38 @@ fn aiur_fn_177( unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(80); - let __v_1: G = G::from_u64(96); - let __v_2: G = G::from_u64(162); - let __v_3: G = G::from_u64(45); - let __v_4: G = G::from_u64(248); - let __v_5: G = G::from_u64(99); - let __v_6: G = G::from_u64(7); - let __v_7: G = G::from_u64(221); - let __v_8: G = G::from_u64(139); - let __v_9: G = G::from_u64(190); - let __v_10: G = G::from_u64(101); - let __v_11: G = G::from_u64(110); - let __v_12: G = G::from_u64(19); - let __v_13: G = G::from_u64(134); - let __v_14: G = G::from_u64(143); - let __v_15: G = G::from_u64(58); - let __v_16: G = G::from_u64(22); - let __v_17: G = G::from_u64(24); - let __v_18: G = G::from_u64(231); - let __v_19: G = G::from_u64(160); - let __v_20: G = G::from_u64(216); - let __v_21: G = G::from_u64(128); - let __v_22: G = G::from_u64(184); - let __v_23: G = G::from_u64(203); - let __v_24: G = G::from_u64(176); - let __v_25: G = G::from_u64(7); - let __v_26: G = G::from_u64(89); - let __v_27: G = G::from_u64(207); - let __v_28: G = G::from_u64(253); - let __v_29: G = G::from_u64(49); - let __v_30: G = G::from_u64(128); - let __v_31: G = G::from_u64(13); + let __v_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_177] = [__v_32]; if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18449,38 +18163,38 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(132); - let __v_1: G = G::from_u64(254); - let __v_2: G = G::from_u64(61); - let __v_3: G = G::from_u64(15); - let __v_4: G = G::from_u64(8); - let __v_5: G = G::from_u64(240); - let __v_6: G = G::from_u64(101); - let __v_7: G = G::from_u64(26); - let __v_8: G = G::from_u64(111); - let __v_9: G = G::from_u64(9); - let __v_10: G = G::from_u64(54); - let __v_11: G = G::from_u64(169); - let __v_12: G = G::from_u64(160); - let __v_13: G = G::from_u64(241); - let __v_14: G = G::from_u64(142); - let __v_15: G = G::from_u64(79); - let __v_16: G = G::from_u64(13); - let __v_17: G = G::from_u64(172); - let __v_18: G = G::from_u64(225); - let __v_19: G = G::from_u64(105); - let __v_20: G = G::from_u64(172); - let __v_21: G = G::from_u64(66); - let __v_22: G = G::from_u64(51); - let __v_23: G = G::from_u64(191); - let __v_24: G = G::from_u64(26); - let __v_25: G = G::from_u64(218); - let __v_26: G = G::from_u64(208); - let __v_27: G = G::from_u64(93); - let __v_28: G = G::from_u64(110); - let __v_29: G = G::from_u64(7); - let __v_30: G = G::from_u64(138); - let __v_31: G = G::from_u64(37); + let __v_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_178] = [__v_32]; if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18498,38 +18212,38 @@ fn aiur_fn_179( unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(212); - let __v_1: G = G::from_u64(215); - let __v_2: G = G::from_u64(117); - let __v_3: G = G::from_u64(206); - let __v_4: G = G::from_u64(255); - let __v_5: G = G::from_u64(55); - let __v_6: G = G::from_u64(171); - let __v_7: G = G::from_u64(122); - let __v_8: G = G::from_u64(64); - let __v_9: G = G::from_u64(36); - let __v_10: G = G::from_u64(22); - let __v_11: G = G::from_u64(17); - let __v_12: G = G::from_u64(143); - let __v_13: G = G::from_u64(29); - let __v_14: G = G::from_u64(44); - let __v_15: G = G::from_u64(229); - let __v_16: G = G::from_u64(185); - let __v_17: G = G::from_u64(231); - let __v_18: G = G::from_u64(242); - let __v_19: G = G::from_u64(20); - let __v_20: G = G::from_u64(61); - let __v_21: G = G::from_u64(12); - let __v_22: G = G::from_u64(61); - let __v_23: G = G::from_u64(200); - let __v_24: G = G::from_u64(254); - let __v_25: G = G::from_u64(84); - let __v_26: G = G::from_u64(49); - let __v_27: G = G::from_u64(87); - let __v_28: G = G::from_u64(29); - let __v_29: G = G::from_u64(243); - let __v_30: G = G::from_u64(38); - let __v_31: G = G::from_u64(12); + let __v_0: G = G::from_u64(12); + let __v_1: G = G::from_u64(112); + let __v_2: G = G::from_u64(114); + let __v_3: G = G::from_u64(169); + let __v_4: G = G::from_u64(39); + let __v_5: G = G::from_u64(177); + let __v_6: G = G::from_u64(196); + let __v_7: G = G::from_u64(110); + let __v_8: G = G::from_u64(252); + let __v_9: G = G::from_u64(148); + let __v_10: G = G::from_u64(152); + let __v_11: G = G::from_u64(231); + let __v_12: G = G::from_u64(73); + let __v_13: G = G::from_u64(184); + let __v_14: G = G::from_u64(50); + let __v_15: G = G::from_u64(11); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(216); + let __v_18: G = G::from_u64(153); + let __v_19: G = G::from_u64(78); + let __v_20: G = G::from_u64(194); + let __v_21: G = G::from_u64(128); + let __v_22: G = G::from_u64(96); + let __v_23: G = G::from_u64(22); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(174); + let __v_27: G = G::from_u64(225); + let __v_28: G = G::from_u64(173); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(108); + let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_179] = [__v_32]; if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18547,38 +18261,38 @@ fn aiur_fn_180( unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(32); - let __v_1: G = G::from_u64(117); - let __v_2: G = G::from_u64(189); - let __v_3: G = G::from_u64(165); - let __v_4: G = G::from_u64(69); - let __v_5: G = G::from_u64(123); - let __v_6: G = G::from_u64(41); - let __v_7: G = G::from_u64(155); - let __v_8: G = G::from_u64(39); - let __v_9: G = G::from_u64(36); - let __v_10: G = G::from_u64(103); - let __v_11: G = G::from_u64(112); - let __v_12: G = G::from_u64(200); - let __v_13: G = G::from_u64(65); - let __v_14: G = G::from_u64(98); - let __v_15: G = G::from_u64(115); - let __v_16: G = G::from_u64(104); - let __v_17: G = G::from_u64(107); - let __v_18: G = G::from_u64(191); - let __v_19: G = G::from_u64(98); - let __v_20: G = G::from_u64(122); - let __v_21: G = G::from_u64(166); - let __v_22: G = G::from_u64(160); - let __v_23: G = G::from_u64(26); - let __v_24: G = G::from_u64(196); - let __v_25: G = G::from_u64(19); - let __v_26: G = G::from_u64(162); - let __v_27: G = G::from_u64(126); - let __v_28: G = G::from_u64(88); - let __v_29: G = G::from_u64(62); - let __v_30: G = G::from_u64(185); - let __v_31: G = G::from_u64(93); + let __v_0: G = G::from_u64(102); + let __v_1: G = G::from_u64(242); + let __v_2: G = G::from_u64(155); + let __v_3: G = G::from_u64(230); + let __v_4: G = G::from_u64(224); + let __v_5: G = G::from_u64(10); + let __v_6: G = G::from_u64(200); + let __v_7: G = G::from_u64(53); + let __v_8: G = G::from_u64(99); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(40); + let __v_11: G = G::from_u64(20); + let __v_12: G = G::from_u64(152); + let __v_13: G = G::from_u64(143); + let __v_14: G = G::from_u64(156); + let __v_15: G = G::from_u64(241); + let __v_16: G = G::from_u64(101); + let __v_17: G = G::from_u64(71); + let __v_18: G = G::from_u64(190); + let __v_19: G = G::from_u64(187); + let __v_20: G = G::from_u64(7); + let __v_21: G = G::from_u64(99); + let __v_22: G = G::from_u64(82); + let __v_23: G = G::from_u64(124); + let __v_24: G = G::from_u64(17); + let __v_25: G = G::from_u64(155); + let __v_26: G = G::from_u64(202); + let __v_27: G = G::from_u64(81); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(176); + let __v_30: G = G::from_u64(189); + let __v_31: G = G::from_u64(213); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_180] = [__v_32]; if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18586,8 +18300,8 @@ fn aiur_fn_180( }) } -const INPUT_SIZE_181: usize = 0; -const IN_181: usize = 0; +const INPUT_SIZE_181: usize = 1; +const IN_181: usize = 1; const OUT_181: usize = 1; fn aiur_fn_181( inp: [G; IN_181], @@ -18595,169 +18309,71 @@ fn aiur_fn_181( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(126); - let __v_1: G = G::from_u64(78); - let __v_2: G = G::from_u64(155); - let __v_3: G = G::from_u64(51); - let __v_4: G = G::from_u64(182); - let __v_5: G = G::from_u64(150); - let __v_6: G = G::from_u64(167); - let __v_7: G = G::from_u64(211); - let __v_8: G = G::from_u64(252); - let __v_9: G = G::from_u64(225); - let __v_10: G = G::from_u64(116); - let __v_11: G = G::from_u64(93); - let __v_12: G = G::from_u64(251); - let __v_13: G = G::from_u64(95); - let __v_14: G = G::from_u64(190); - let __v_15: G = G::from_u64(235); - let __v_16: G = G::from_u64(147); - let __v_17: G = G::from_u64(143); - let __v_18: G = G::from_u64(200); - let __v_19: G = G::from_u64(136); - let __v_20: G = G::from_u64(42); - let __v_21: G = G::from_u64(130); - let __v_22: G = G::from_u64(190); - let __v_23: G = G::from_u64(225); - let __v_24: G = G::from_u64(87); - let __v_25: G = G::from_u64(35); - let __v_26: G = G::from_u64(224); - let __v_27: G = G::from_u64(210); - let __v_28: G = G::from_u64(83); - let __v_29: G = G::from_u64(229); - let __v_30: G = G::from_u64(145); - let __v_31: G = G::from_u64(88); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_32]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(128); - let __v_1: G = G::from_u64(249); - let __v_2: G = G::from_u64(117); - let __v_3: G = G::from_u64(222); - let __v_4: G = G::from_u64(217); - let __v_5: G = G::from_u64(214); - let __v_6: G = G::from_u64(171); - let __v_7: G = G::from_u64(112); - let __v_8: G = G::from_u64(149); - let __v_9: G = G::from_u64(233); - let __v_10: G = G::from_u64(219); - let __v_11: G = G::from_u64(46); - let __v_12: G = G::from_u64(209); - let __v_13: G = G::from_u64(207); - let __v_14: G = G::from_u64(166); - let __v_15: G = G::from_u64(245); - let __v_16: G = G::from_u64(195); - let __v_17: G = G::from_u64(94); - let __v_18: G = G::from_u64(175); - let __v_19: G = G::from_u64(229); - let __v_20: G = G::from_u64(197); - let __v_21: G = G::from_u64(105); - let __v_22: G = G::from_u64(144); - let __v_23: G = G::from_u64(226); - let __v_24: G = G::from_u64(193); - let __v_25: G = G::from_u64(50); - let __v_26: G = G::from_u64(27); - let __v_27: G = G::from_u64(2); - let __v_28: G = G::from_u64(197); - let __v_29: G = G::from_u64(102); - let __v_30: G = G::from_u64(78); - let __v_31: G = G::from_u64(108); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_32]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_183: usize = 1; -const IN_183: usize = 1; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_3]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_3]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_5]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_5]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_7]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_7]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_9]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_9]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_11]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_11]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_183] = [__v_11]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_11]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18772,15 +18388,15 @@ fn aiur_fn_183( }) } -const INPUT_SIZE_184: usize = 0; -const IN_184: usize = 0; -const OUT_184: usize = 1; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); @@ -18799,21 +18415,21 @@ fn aiur_fn_184( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_16]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_16]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_185: usize = 0; -const IN_185: usize = 0; -const OUT_185: usize = 1; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_183: usize = 0; +const IN_183: usize = 0; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); @@ -18832,74 +18448,74 @@ fn aiur_fn_185( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_16]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_16]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_186: usize = 3; -const IN_186: usize = 3; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_184: usize = 3; +const IN_184: usize = 3; +const OUT_184: usize = 2; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -18909,12 +18525,12 @@ fn aiur_fn_186( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18925,31 +18541,31 @@ fn aiur_fn_186( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18966,18 +18582,18 @@ fn aiur_fn_186( }) } -const INPUT_SIZE_187: usize = 1; -const IN_187: usize = 1; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_185: usize = 1; +const IN_185: usize = 1; +const OUT_185: usize = 2; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18988,15 +18604,15 @@ fn aiur_fn_187( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19006,17 +18622,17 @@ fn aiur_fn_187( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19025,8 +18641,8 @@ fn aiur_fn_187( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19037,8 +18653,8 @@ fn aiur_fn_187( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19047,15 +18663,15 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 1; -const IN_188: usize = 1; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_186: usize = 1; +const IN_186: usize = 1; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19065,13 +18681,13 @@ fn aiur_fn_188( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -19081,14 +18697,14 @@ fn aiur_fn_188( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_188] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_10, __v_0]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19099,23 +18715,23 @@ fn aiur_fn_188( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_187: usize = 1; +const IN_187: usize = 1; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19128,8 +18744,8 @@ fn aiur_fn_189( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_189] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_0]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19138,8 +18754,8 @@ fn aiur_fn_189( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19150,14 +18766,112 @@ fn aiur_fn_189( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } +const INPUT_SIZE_188: usize = 0; +const IN_188: usize = 0; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_188], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(227); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(180); + let __v_3: G = G::from_u64(231); + let __v_4: G = G::from_u64(114); + let __v_5: G = G::from_u64(13); + let __v_6: G = G::from_u64(52); + let __v_7: G = G::from_u64(66); + let __v_8: G = G::from_u64(162); + let __v_9: G = G::from_u64(102); + let __v_10: G = G::from_u64(179); + let __v_11: G = G::from_u64(124); + let __v_12: G = G::from_u64(151); + let __v_13: G = G::from_u64(162); + let __v_14: G = G::from_u64(114); + let __v_15: G = G::from_u64(24); + let __v_16: G = G::from_u64(230); + let __v_17: G = G::from_u64(130); + let __v_18: G = G::from_u64(57); + let __v_19: G = G::from_u64(49); + let __v_20: G = G::from_u64(131); + let __v_21: G = G::from_u64(17); + let __v_22: G = G::from_u64(248); + let __v_23: G = G::from_u64(228); + let __v_24: G = G::from_u64(176); + let __v_25: G = G::from_u64(70); + let __v_26: G = G::from_u64(166); + let __v_27: G = G::from_u64(189); + let __v_28: G = G::from_u64(222); + let __v_29: G = G::from_u64(82); + let __v_30: G = G::from_u64(3); + let __v_31: G = G::from_u64(116); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_188] = [__v_32]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_189: usize = 0; +const IN_189: usize = 0; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_189], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(59); + let __v_1: G = G::from_u64(51); + let __v_2: G = G::from_u64(76); + let __v_3: G = G::from_u64(148); + let __v_4: G = G::from_u64(221); + let __v_5: G = G::from_u64(86); + let __v_6: G = G::from_u64(216); + let __v_7: G = G::from_u64(11); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(78); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(93); + let __v_12: G = G::from_u64(130); + let __v_13: G = G::from_u64(95); + let __v_14: G = G::from_u64(103); + let __v_15: G = G::from_u64(246); + let __v_16: G = G::from_u64(241); + let __v_17: G = G::from_u64(172); + let __v_18: G = G::from_u64(78); + let __v_19: G = G::from_u64(20); + let __v_20: G = G::from_u64(4); + let __v_21: G = G::from_u64(3); + let __v_22: G = G::from_u64(105); + let __v_23: G = G::from_u64(158); + let __v_24: G = G::from_u64(61); + let __v_25: G = G::from_u64(175); + let __v_26: G = G::from_u64(245); + let __v_27: G = G::from_u64(42); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(189); + let __v_30: G = G::from_u64(191); + let __v_31: G = G::from_u64(110); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_189] = [__v_32]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + const INPUT_SIZE_190: usize = 0; const IN_190: usize = 0; const OUT_190: usize = 1; @@ -19168,38 +18882,38 @@ fn aiur_fn_190( unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(172); - let __v_1: G = G::from_u64(217); - let __v_2: G = G::from_u64(240); - let __v_3: G = G::from_u64(163); - let __v_4: G = G::from_u64(247); - let __v_5: G = G::from_u64(232); - let __v_6: G = G::from_u64(197); - let __v_7: G = G::from_u64(58); - let __v_8: G = G::from_u64(70); - let __v_9: G = G::from_u64(185); - let __v_10: G = G::from_u64(23); - let __v_11: G = G::from_u64(89); - let __v_12: G = G::from_u64(53); - let __v_13: G = G::from_u64(131); - let __v_14: G = G::from_u64(102); - let __v_15: G = G::from_u64(250); - let __v_16: G = G::from_u64(2); - let __v_17: G = G::from_u64(130); - let __v_18: G = G::from_u64(64); - let __v_19: G = G::from_u64(176); - let __v_20: G = G::from_u64(182); - let __v_21: G = G::from_u64(204); - let __v_22: G = G::from_u64(9); - let __v_23: G = G::from_u64(32); - let __v_24: G = G::from_u64(93); - let __v_25: G = G::from_u64(222); - let __v_26: G = G::from_u64(52); - let __v_27: G = G::from_u64(163); - let __v_28: G = G::from_u64(53); - let __v_29: G = G::from_u64(68); - let __v_30: G = G::from_u64(103); - let __v_31: G = G::from_u64(141); + let __v_0: G = G::from_u64(103); + let __v_1: G = G::from_u64(244); + let __v_2: G = G::from_u64(116); + let __v_3: G = G::from_u64(184); + let __v_4: G = G::from_u64(195); + let __v_5: G = G::from_u64(48); + let __v_6: G = G::from_u64(43); + let __v_7: G = G::from_u64(4); + let __v_8: G = G::from_u64(65); + let __v_9: G = G::from_u64(127); + let __v_10: G = G::from_u64(114); + let __v_11: G = G::from_u64(31); + let __v_12: G = G::from_u64(243); + let __v_13: G = G::from_u64(232); + let __v_14: G = G::from_u64(140); + let __v_15: G = G::from_u64(230); + let __v_16: G = G::from_u64(241); + let __v_17: G = G::from_u64(106); + let __v_18: G = G::from_u64(125); + let __v_19: G = G::from_u64(252); + let __v_20: G = G::from_u64(179); + let __v_21: G = G::from_u64(186); + let __v_22: G = G::from_u64(233); + let __v_23: G = G::from_u64(147); + let __v_24: G = G::from_u64(104); + let __v_25: G = G::from_u64(8); + let __v_26: G = G::from_u64(93); + let __v_27: G = G::from_u64(28); + let __v_28: G = G::from_u64(94); + let __v_29: G = G::from_u64(135); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_190] = [__v_32]; if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -19217,38 +18931,38 @@ fn aiur_fn_191( unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(87); - let __v_1: G = G::from_u64(33); - let __v_2: G = G::from_u64(202); - let __v_3: G = G::from_u64(42); - let __v_4: G = G::from_u64(207); - let __v_5: G = G::from_u64(44); - let __v_6: G = G::from_u64(105); - let __v_7: G = G::from_u64(148); - let __v_8: G = G::from_u64(119); - let __v_9: G = G::from_u64(21); - let __v_10: G = G::from_u64(9); - let __v_11: G = G::from_u64(51); - let __v_12: G = G::from_u64(47); - let __v_13: G = G::from_u64(177); - let __v_14: G = G::from_u64(133); - let __v_15: G = G::from_u64(247); - let __v_16: G = G::from_u64(131); - let __v_17: G = G::from_u64(244); - let __v_18: G = G::from_u64(66); - let __v_19: G = G::from_u64(174); - let __v_20: G = G::from_u64(252); - let __v_21: G = G::from_u64(228); - let __v_22: G = G::from_u64(23); - let __v_23: G = G::from_u64(210); - let __v_24: G = G::from_u64(134); - let __v_25: G = G::from_u64(62); - let __v_26: G = G::from_u64(45); - let __v_27: G = G::from_u64(20); - let __v_28: G = G::from_u64(142); - let __v_29: G = G::from_u64(220); - let __v_30: G = G::from_u64(219); - let __v_31: G = G::from_u64(138); + let __v_0: G = G::from_u64(79); + let __v_1: G = G::from_u64(157); + let __v_2: G = G::from_u64(78); + let __v_3: G = G::from_u64(12); + let __v_4: G = G::from_u64(112); + let __v_5: G = G::from_u64(225); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(224); + let __v_9: G = G::from_u64(237); + let __v_10: G = G::from_u64(163); + let __v_11: G = G::from_u64(142); + let __v_12: G = G::from_u64(45); + let __v_13: G = G::from_u64(109); + let __v_14: G = G::from_u64(148); + let __v_15: G = G::from_u64(204); + let __v_16: G = G::from_u64(209); + let __v_17: G = G::from_u64(37); + let __v_18: G = G::from_u64(152); + let __v_19: G = G::from_u64(117); + let __v_20: G = G::from_u64(94); + let __v_21: G = G::from_u64(14); + let __v_22: G = G::from_u64(114); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(169); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(157); + let __v_27: G = G::from_u64(169); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(144); + let __v_30: G = G::from_u64(87); + let __v_31: G = G::from_u64(204); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_191] = [__v_32]; if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -19266,38 +18980,38 @@ fn aiur_fn_192( unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(199); - let __v_1: G = G::from_u64(25); - let __v_2: G = G::from_u64(42); - let __v_3: G = G::from_u64(197); - let __v_4: G = G::from_u64(7); - let __v_5: G = G::from_u64(214); - let __v_6: G = G::from_u64(124); - let __v_7: G = G::from_u64(60); - let __v_8: G = G::from_u64(62); - let __v_9: G = G::from_u64(30); - let __v_10: G = G::from_u64(185); - let __v_11: G = G::from_u64(6); - let __v_12: G = G::from_u64(51); - let __v_13: G = G::from_u64(133); - let __v_14: G = G::from_u64(138); - let __v_15: G = G::from_u64(231); - let __v_16: G = G::from_u64(183); - let __v_17: G = G::from_u64(203); - let __v_18: G = G::from_u64(200); - let __v_19: G = G::from_u64(14); - let __v_20: G = G::from_u64(57); - let __v_21: G = G::from_u64(136); - let __v_22: G = G::from_u64(49); - let __v_23: G = G::from_u64(38); - let __v_24: G = G::from_u64(24); - let __v_25: G = G::from_u64(199); - let __v_26: G = G::from_u64(236); - let __v_27: G = G::from_u64(9); - let __v_28: G = G::from_u64(180); - let __v_29: G = G::from_u64(131); - let __v_30: G = G::from_u64(176); - let __v_31: G = G::from_u64(74); + let __v_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_192] = [__v_32]; if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -19315,38 +19029,38 @@ fn aiur_fn_193( unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(141); - let __v_1: G = G::from_u64(87); - let __v_2: G = G::from_u64(199); - let __v_3: G = G::from_u64(198); - let __v_4: G = G::from_u64(174); - let __v_5: G = G::from_u64(225); + 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(81); - let __v_8: G = G::from_u64(13); - let __v_9: G = G::from_u64(50); - let __v_10: G = G::from_u64(8); - let __v_11: G = G::from_u64(221); - let __v_12: G = G::from_u64(196); - let __v_13: G = G::from_u64(176); - let __v_14: G = G::from_u64(138); - let __v_15: G = G::from_u64(131); - let __v_16: G = G::from_u64(180); - let __v_17: G = G::from_u64(67); - let __v_18: G = G::from_u64(25); - let __v_19: G = G::from_u64(246); - let __v_20: G = G::from_u64(175); - let __v_21: G = G::from_u64(142); - let __v_22: G = G::from_u64(224); - let __v_23: G = G::from_u64(155); - let __v_24: G = G::from_u64(57); - let __v_25: G = G::from_u64(64); - let __v_26: G = G::from_u64(208); - let __v_27: G = G::from_u64(221); - let __v_28: G = G::from_u64(237); - let __v_29: G = G::from_u64(206); - let __v_30: G = G::from_u64(30); - let __v_31: G = G::from_u64(182); + let __v_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_193] = [__v_32]; if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -19354,8 +19068,8 @@ fn aiur_fn_193( }) } -const INPUT_SIZE_194: usize = 0; -const IN_194: usize = 0; +const INPUT_SIZE_194: usize = 1; +const IN_194: usize = 1; const OUT_194: usize = 1; fn aiur_fn_194( inp: [G; IN_194], @@ -19363,145 +19077,47 @@ fn aiur_fn_194( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_194], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(209); - let __v_1: G = G::from_u64(16); - let __v_2: G = G::from_u64(124); - let __v_3: G = G::from_u64(153); - let __v_4: G = G::from_u64(173); - let __v_5: G = G::from_u64(158); - let __v_6: G = G::from_u64(188); - let __v_7: G = G::from_u64(181); - let __v_8: G = G::from_u64(2); - let __v_9: G = G::from_u64(141); - let __v_10: G = G::from_u64(154); - let __v_11: G = G::from_u64(234); - let __v_12: G = G::from_u64(13); - let __v_13: G = G::from_u64(165); - let __v_14: G = G::from_u64(33); - let __v_15: G = G::from_u64(237); - let __v_16: G = G::from_u64(92); - let __v_17: G = G::from_u64(18); - let __v_18: G = G::from_u64(231); - let __v_19: G = G::from_u64(30); - let __v_20: G = G::from_u64(162); - let __v_21: G = G::from_u64(236); - let __v_22: G = G::from_u64(222); - let __v_23: G = G::from_u64(175); - let __v_24: G = G::from_u64(99); - let __v_25: G = G::from_u64(123); - let __v_26: G = G::from_u64(180); - let __v_27: G = G::from_u64(161); - let __v_28: G = G::from_u64(77); - let __v_29: G = G::from_u64(74); - let __v_30: G = G::from_u64(126); - let __v_31: G = G::from_u64(68); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_32]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_195: usize = 0; -const IN_195: usize = 0; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(198); - let __v_1: G = G::from_u64(157); - let __v_2: G = G::from_u64(244); - let __v_3: G = G::from_u64(131); - let __v_4: G = G::from_u64(62); - let __v_5: G = G::from_u64(205); - let __v_6: G = G::from_u64(206); - let __v_7: G = G::from_u64(118); - let __v_8: G = G::from_u64(189); - let __v_9: G = G::from_u64(176); - let __v_10: G = G::from_u64(210); - let __v_11: G = G::from_u64(49); - let __v_12: G = G::from_u64(89); - let __v_13: G = G::from_u64(225); - let __v_14: G = G::from_u64(250); - let __v_15: G = G::from_u64(198); - let __v_16: G = G::from_u64(82); - let __v_17: G = G::from_u64(216); - let __v_18: G = G::from_u64(137); - let __v_19: G = G::from_u64(25); - let __v_20: G = G::from_u64(118); - let __v_21: G = G::from_u64(140); - let __v_22: G = G::from_u64(49); - let __v_23: G = G::from_u64(44); - let __v_24: G = G::from_u64(102); - let __v_25: G = G::from_u64(17); - let __v_26: G = G::from_u64(220); - let __v_27: G = G::from_u64(6); - let __v_28: G = G::from_u64(13); - let __v_29: G = G::from_u64(161); - let __v_30: G = G::from_u64(111); - let __v_31: G = G::from_u64(4); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_32]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_196] = [__v_3]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_3]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_196] = [__v_5]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_5]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_196] = [__v_7]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_196] = [__v_7]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19512,61 +19128,61 @@ fn aiur_fn_196( }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -const OUT_197: usize = 1; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_195: usize = 1; +const IN_195: usize = 1; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_7]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_7]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_7]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_7]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_198: usize = 2; -const IN_198: usize = 2; -const OUT_198: usize = 2; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_196: usize = 2; +const IN_196: usize = 2; +const OUT_196: usize = 2; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -19576,12 +19192,12 @@ fn aiur_fn_198( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19590,12 +19206,12 @@ fn aiur_fn_198( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19604,8 +19220,8 @@ fn aiur_fn_198( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -19622,15 +19238,15 @@ fn aiur_fn_198( let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_198] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_23, __v_25]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19650,18 +19266,18 @@ fn aiur_fn_198( }) } -const INPUT_SIZE_199: usize = 1; -const IN_199: usize = 1; -const OUT_199: usize = 2; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 2; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19672,21 +19288,21 @@ fn aiur_fn_199( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19696,12 +19312,12 @@ fn aiur_fn_199( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19711,20 +19327,20 @@ fn aiur_fn_199( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_199] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19741,18 +19357,18 @@ fn aiur_fn_199( }) } -const INPUT_SIZE_200: usize = 1; -const IN_200: usize = 1; -const OUT_200: usize = 2; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 2; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19763,15 +19379,15 @@ fn aiur_fn_200( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19781,9 +19397,9 @@ fn aiur_fn_200( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -19792,12 +19408,12 @@ fn aiur_fn_200( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19808,15 +19424,15 @@ fn aiur_fn_200( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19826,9 +19442,9 @@ fn aiur_fn_200( let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { @@ -19837,12 +19453,12 @@ fn aiur_fn_200( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_27, __v_31]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19853,19 +19469,19 @@ fn aiur_fn_200( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_30, __v_34]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); @@ -19876,11 +19492,11 @@ fn aiur_fn_200( let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_200] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19893,8 +19509,8 @@ fn aiur_fn_200( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_25, __v_29]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19909,8 +19525,8 @@ fn aiur_fn_200( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19919,18 +19535,18 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 3; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_199: usize = 1; +const IN_199: usize = 1; +const OUT_199: usize = 3; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19940,13 +19556,13 @@ fn aiur_fn_201( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19954,13 +19570,13 @@ fn aiur_fn_201( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_201] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_12, __v_14, __v_16]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19973,8 +19589,8 @@ fn aiur_fn_201( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_12, __v_16, __v_20]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19989,8 +19605,8 @@ fn aiur_fn_201( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_13, __v_17]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20005,34 +19621,34 @@ fn aiur_fn_201( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_7, __v_11, __v_15]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_202: usize = 3; -const IN_202: usize = 3; -const OUT_202: usize = 2; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_200: usize = 3; +const IN_200: usize = 3; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -20043,20 +19659,20 @@ fn aiur_fn_202( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -20066,16 +19682,16 @@ fn aiur_fn_202( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_202] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20086,33 +19702,33 @@ fn aiur_fn_202( } }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_202] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_202] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20121,8 +19737,8 @@ fn aiur_fn_202( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20133,19 +19749,19 @@ fn aiur_fn_202( }) } -const INPUT_SIZE_203: usize = 2; -const IN_203: usize = 2; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_201: usize = 2; +const IN_201: usize = 2; +const OUT_201: usize = 1; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __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]; @@ -20153,8 +19769,8 @@ fn aiur_fn_203( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_203] = [__v_2]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20164,8 +19780,8 @@ fn aiur_fn_203( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_203] = [__v_2]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20175,14 +19791,14 @@ fn aiur_fn_203( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_203] = [__v_2]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -20190,8 +19806,8 @@ fn aiur_fn_203( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_19]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_19]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20211,26 +19827,124 @@ fn aiur_fn_203( }) } -const INPUT_SIZE_204: usize = 2; -const IN_204: usize = 2; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_202: usize = 2; +const IN_202: usize = 2; +const OUT_202: usize = 1; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_204] = [__v_5]; + let __ret: [G; OUT_202] = [__v_5]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_203: usize = 0; +const IN_203: usize = 0; +const OUT_203: usize = 1; +fn aiur_fn_203( + inp: [G; IN_203], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_203], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(81); + let __v_1: G = G::from_u64(134); + let __v_2: G = G::from_u64(217); + let __v_3: G = G::from_u64(30); + let __v_4: G = G::from_u64(248); + let __v_5: G = G::from_u64(137); + let __v_6: G = G::from_u64(46); + let __v_7: G = G::from_u64(72); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(145); + let __v_11: G = G::from_u64(139); + let __v_12: G = G::from_u64(9); + let __v_13: G = G::from_u64(38); + let __v_14: G = G::from_u64(233); + let __v_15: G = G::from_u64(118); + let __v_16: G = G::from_u64(124); + let __v_17: G = G::from_u64(109); + let __v_18: G = G::from_u64(75); + let __v_19: G = G::from_u64(155); + let __v_20: G = G::from_u64(8); + let __v_21: G = G::from_u64(20); + let __v_22: G = G::from_u64(6); + let __v_23: G = G::from_u64(74); + let __v_24: G = G::from_u64(68); + let __v_25: G = G::from_u64(154); + let __v_26: G = G::from_u64(90); + let __v_27: G = G::from_u64(254); + let __v_28: G = G::from_u64(138); + let __v_29: G = G::from_u64(158); + let __v_30: G = G::from_u64(90); + let __v_31: G = G::from_u64(110); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_203] = [__v_32]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_204: usize = 0; +const IN_204: usize = 0; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_204], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(255); + let __v_1: G = G::from_u64(69); + let __v_2: G = G::from_u64(149); + let __v_3: G = G::from_u64(84); + let __v_4: G = G::from_u64(223); + let __v_5: G = G::from_u64(220); + let __v_6: G = G::from_u64(52); + let __v_7: G = G::from_u64(209); + let __v_8: G = G::from_u64(89); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(112); + let __v_11: G = G::from_u64(56); + let __v_12: G = G::from_u64(23); + let __v_13: G = G::from_u64(69); + let __v_14: G = G::from_u64(113); + let __v_15: G = G::from_u64(183); + let __v_16: G = G::from_u64(112); + let __v_17: G = G::from_u64(70); + let __v_18: G = G::from_u64(77); + let __v_19: G = G::from_u64(82); + let __v_20: G = G::from_u64(131); + let __v_21: G = G::from_u64(76); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(188); + let __v_24: G = G::from_u64(100); + let __v_25: G = G::from_u64(54); + let __v_26: G = G::from_u64(70); + let __v_27: G = G::from_u64(127); + let __v_28: G = G::from_u64(168); + let __v_29: G = G::from_u64(29); + let __v_30: G = G::from_u64(3); + let __v_31: G = G::from_u64(158); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_204] = [__v_32]; if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -20246,38 +19960,38 @@ fn aiur_fn_205( unconstrained: bool, ) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(177); - let __v_1: G = G::from_u64(246); - let __v_2: G = G::from_u64(240); - let __v_3: G = G::from_u64(75); - let __v_4: G = G::from_u64(222); - let __v_5: G = G::from_u64(61); - let __v_6: G = G::from_u64(129); - let __v_7: G = G::from_u64(249); - let __v_8: G = G::from_u64(16); - let __v_9: G = G::from_u64(46); - let __v_10: G = G::from_u64(166); - let __v_11: G = G::from_u64(183); - let __v_12: G = G::from_u64(210); - let __v_13: G = G::from_u64(201); - let __v_14: G = G::from_u64(244); - let __v_15: G = G::from_u64(35); - let __v_16: G = G::from_u64(109); - let __v_17: G = G::from_u64(114); - let __v_18: G = G::from_u64(177); - let __v_19: G = G::from_u64(126); - let __v_20: G = G::from_u64(1); - let __v_21: G = G::from_u64(18); - let __v_22: G = G::from_u64(85); - let __v_23: G = G::from_u64(35); - let __v_24: G = G::from_u64(197); - let __v_25: G = G::from_u64(213); - let __v_26: G = G::from_u64(226); - let __v_27: G = G::from_u64(97); - let __v_28: G = G::from_u64(175); - let __v_29: G = G::from_u64(199); - let __v_30: G = G::from_u64(17); - let __v_31: G = G::from_u64(5); + let __v_0: G = G::from_u64(15); + let __v_1: G = G::from_u64(2); + let __v_2: G = G::from_u64(80); + let __v_3: G = G::from_u64(215); + let __v_4: G = G::from_u64(113); + let __v_5: G = G::from_u64(55); + let __v_6: G = G::from_u64(4); + let __v_7: G = G::from_u64(67); + let __v_8: G = G::from_u64(144); + let __v_9: G = G::from_u64(115); + let __v_10: G = G::from_u64(186); + let __v_11: G = G::from_u64(189); + let __v_12: G = G::from_u64(81); + let __v_13: G = G::from_u64(27); + let __v_14: G = G::from_u64(119); + let __v_15: G = G::from_u64(169); + let __v_16: G = G::from_u64(238); + let __v_17: G = G::from_u64(234); + let __v_18: G = G::from_u64(229); + let __v_19: G = G::from_u64(173); + let __v_20: G = G::from_u64(189); + let __v_21: G = G::from_u64(80); + let __v_22: G = G::from_u64(255); + let __v_23: G = G::from_u64(87); + let __v_24: G = G::from_u64(77); + let __v_25: G = G::from_u64(128); + let __v_26: G = G::from_u64(31); + let __v_27: G = G::from_u64(251); + let __v_28: G = G::from_u64(85); + let __v_29: G = G::from_u64(129); + let __v_30: G = G::from_u64(40); + let __v_31: G = G::from_u64(217); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_205] = [__v_32]; if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20295,38 +20009,38 @@ fn aiur_fn_206( unconstrained: bool, ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(182); - let __v_1: G = G::from_u64(236); - let __v_2: G = G::from_u64(45); - let __v_3: G = G::from_u64(68); - let __v_4: G = G::from_u64(63); - let __v_5: G = G::from_u64(62); - let __v_6: G = G::from_u64(230); - let __v_7: G = G::from_u64(29); - let __v_8: G = G::from_u64(228); - let __v_9: G = G::from_u64(90); - let __v_10: G = G::from_u64(216); - let __v_11: G = G::from_u64(89); - let __v_12: G = G::from_u64(184); - let __v_13: G = G::from_u64(204); - let __v_14: G = G::from_u64(65); - let __v_15: G = G::from_u64(168); - let __v_16: G = G::from_u64(150); - let __v_17: G = G::from_u64(216); - let __v_18: G = G::from_u64(251); - let __v_19: G = G::from_u64(164); - let __v_20: G = G::from_u64(155); - let __v_21: G = G::from_u64(194); - let __v_22: G = G::from_u64(152); - let __v_23: G = G::from_u64(131); - let __v_24: G = G::from_u64(252); - let __v_25: G = G::from_u64(52); - let __v_26: G = G::from_u64(196); - let __v_27: G = G::from_u64(39); - let __v_28: G = G::from_u64(219); - let __v_29: G = G::from_u64(223); - let __v_30: G = G::from_u64(113); - let __v_31: G = G::from_u64(248); + let __v_0: G = G::from_u64(9); + let __v_1: G = G::from_u64(238); + let __v_2: G = G::from_u64(180); + let __v_3: G = G::from_u64(22); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(64); + let __v_6: G = G::from_u64(118); + let __v_7: G = G::from_u64(102); + let __v_8: G = G::from_u64(100); + let __v_9: G = G::from_u64(87); + let __v_10: G = G::from_u64(65); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(75); + let __v_13: G = G::from_u64(124); + let __v_14: G = G::from_u64(227); + let __v_15: G = G::from_u64(209); + let __v_16: G = G::from_u64(191); + let __v_17: G = G::from_u64(52); + let __v_18: G = G::from_u64(151); + let __v_19: G = G::from_u64(125); + let __v_20: G = G::from_u64(63); + let __v_21: G = G::from_u64(86); + let __v_22: G = G::from_u64(221); + let __v_23: G = G::from_u64(37); + let __v_24: G = G::from_u64(98); + let __v_25: G = G::from_u64(192); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(74); + let __v_28: G = G::from_u64(81); + let __v_29: G = G::from_u64(203); + let __v_30: G = G::from_u64(141); + let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_32]; if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20344,38 +20058,38 @@ fn aiur_fn_207( unconstrained: bool, ) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(213); - let __v_1: G = G::from_u64(77); - let __v_2: G = G::from_u64(183); - let __v_3: G = G::from_u64(31); - let __v_4: G = G::from_u64(238); - let __v_5: G = G::from_u64(85); - let __v_6: G = G::from_u64(49); - let __v_7: G = G::from_u64(26); - let __v_8: G = G::from_u64(175); - let __v_9: G = G::from_u64(238); - let __v_10: G = G::from_u64(173); - let __v_11: G = G::from_u64(116); - let __v_12: G = G::from_u64(118); - let __v_13: G = G::from_u64(142); - let __v_14: G = G::from_u64(110); - let __v_15: G = G::from_u64(149); - let __v_16: G = G::from_u64(34); - let __v_17: G = G::from_u64(98); - let __v_18: G = G::from_u64(194); - let __v_19: G = G::from_u64(154); - let __v_20: G = G::from_u64(189); - let __v_21: G = G::from_u64(36); - let __v_22: G = G::from_u64(185); - let __v_23: G = G::from_u64(49); - let __v_24: G = G::from_u64(159); - let __v_25: G = G::from_u64(166); - let __v_26: G = G::from_u64(133); - let __v_27: G = G::from_u64(148); - let __v_28: G = G::from_u64(129); - let __v_29: G = G::from_u64(221); - let __v_30: G = G::from_u64(68); - let __v_31: G = G::from_u64(184); + let __v_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_207] = [__v_32]; if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20393,38 +20107,38 @@ fn aiur_fn_208( unconstrained: bool, ) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(41); - let __v_1: G = G::from_u64(86); - let __v_2: G = G::from_u64(61); - let __v_3: G = G::from_u64(162); - let __v_4: G = G::from_u64(113); - let __v_5: G = G::from_u64(194); - let __v_6: G = G::from_u64(63); - let __v_7: G = G::from_u64(102); - let __v_8: G = G::from_u64(178); - let __v_9: G = G::from_u64(125); - let __v_10: G = G::from_u64(5); - let __v_11: G = G::from_u64(249); - let __v_12: G = G::from_u64(36); - let __v_13: G = G::from_u64(251); - let __v_14: G = G::from_u64(6); - let __v_15: G = G::from_u64(18); - let __v_16: G = G::from_u64(39); - let __v_17: G = G::from_u64(45); - let __v_18: G = G::from_u64(207); - let __v_19: G = G::from_u64(186); - let __v_20: G = G::from_u64(107); - let __v_21: G = G::from_u64(16); - let __v_22: G = G::from_u64(131); - let __v_23: G = G::from_u64(179); - let __v_24: G = G::from_u64(72); - let __v_25: G = G::from_u64(115); - let __v_26: G = G::from_u64(62); - let __v_27: G = G::from_u64(0); - let __v_28: G = G::from_u64(249); - let __v_29: G = G::from_u64(179); - let __v_30: G = G::from_u64(107); - let __v_31: G = G::from_u64(42); + let __v_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_208] = [__v_32]; if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20442,38 +20156,38 @@ fn aiur_fn_209( unconstrained: bool, ) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(60); - let __v_1: G = G::from_u64(1); - let __v_2: G = G::from_u64(73); - let __v_3: G = G::from_u64(195); - let __v_4: G = G::from_u64(67); - let __v_5: G = G::from_u64(41); - let __v_6: G = G::from_u64(105); - let __v_7: G = G::from_u64(238); - let __v_8: G = G::from_u64(93); - let __v_9: G = G::from_u64(147); - let __v_10: G = G::from_u64(84); - let __v_11: G = G::from_u64(200); - let __v_12: G = G::from_u64(210); - let __v_13: G = G::from_u64(216); - let __v_14: G = G::from_u64(156); - let __v_15: G = G::from_u64(238); - let __v_16: G = G::from_u64(196); - let __v_17: G = G::from_u64(167); - let __v_18: G = G::from_u64(151); - let __v_19: G = G::from_u64(17); - let __v_20: G = G::from_u64(248); - let __v_21: G = G::from_u64(222); - let __v_22: G = G::from_u64(200); - let __v_23: G = G::from_u64(113); - let __v_24: G = G::from_u64(8); - let __v_25: G = G::from_u64(121); - let __v_26: G = G::from_u64(161); - let __v_27: G = G::from_u64(42); - let __v_28: G = G::from_u64(18); - let __v_29: G = G::from_u64(183); - let __v_30: G = G::from_u64(44); - let __v_31: G = G::from_u64(66); + let __v_0: G = G::from_u64(32); + let __v_1: G = G::from_u64(59); + let __v_2: G = G::from_u64(118); + let __v_3: G = G::from_u64(197); + let __v_4: G = G::from_u64(180); + let __v_5: G = G::from_u64(245); + let __v_6: G = G::from_u64(202); + let __v_7: G = G::from_u64(6); + let __v_8: G = G::from_u64(21); + let __v_9: G = G::from_u64(99); + let __v_10: G = G::from_u64(49); + let __v_11: G = G::from_u64(64); + let __v_12: G = G::from_u64(87); + let __v_13: G = G::from_u64(169); + let __v_14: G = G::from_u64(67); + let __v_15: G = G::from_u64(188); + let __v_16: G = G::from_u64(67); + let __v_17: G = G::from_u64(128); + let __v_18: G = G::from_u64(136); + let __v_19: G = G::from_u64(94); + let __v_20: G = G::from_u64(115); + let __v_21: G = G::from_u64(208); + let __v_22: G = G::from_u64(239); + let __v_23: G = G::from_u64(175); + let __v_24: G = G::from_u64(20); + let __v_25: G = G::from_u64(100); + let __v_26: G = G::from_u64(69); + let __v_27: G = G::from_u64(152); + let __v_28: G = G::from_u64(194); + let __v_29: G = G::from_u64(250); + let __v_30: G = G::from_u64(110); + let __v_31: G = G::from_u64(238); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_209] = [__v_32]; if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20491,38 +20205,38 @@ fn aiur_fn_210( unconstrained: bool, ) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(209); - let __v_1: G = G::from_u64(224); - let __v_2: G = G::from_u64(128); - let __v_3: G = G::from_u64(44); - let __v_4: G = G::from_u64(56); - let __v_5: G = G::from_u64(188); - let __v_6: G = G::from_u64(218); - let __v_7: G = G::from_u64(20); - let __v_8: G = G::from_u64(6); - let __v_9: G = G::from_u64(30); - let __v_10: G = G::from_u64(32); - let __v_11: G = G::from_u64(18); - let __v_12: G = G::from_u64(241); - let __v_13: G = G::from_u64(46); - let __v_14: G = G::from_u64(115); - let __v_15: G = G::from_u64(194); - let __v_16: G = G::from_u64(162); - let __v_17: G = G::from_u64(74); - let __v_18: G = G::from_u64(103); - let __v_19: G = G::from_u64(17); - let __v_20: G = G::from_u64(55); - let __v_21: G = G::from_u64(152); - let __v_22: G = G::from_u64(79); - let __v_23: G = G::from_u64(142); - let __v_24: G = G::from_u64(247); - let __v_25: G = G::from_u64(103); - let __v_26: G = G::from_u64(68); - let __v_27: G = G::from_u64(234); - let __v_28: G = G::from_u64(4); - let __v_29: G = G::from_u64(209); - let __v_30: G = G::from_u64(136); - let __v_31: G = G::from_u64(196); + let __v_0: G = G::from_u64(84); + let __v_1: G = G::from_u64(139); + let __v_2: G = G::from_u64(191); + let __v_3: G = G::from_u64(34); + let __v_4: G = G::from_u64(186); + let __v_5: G = G::from_u64(48); + let __v_6: G = G::from_u64(95); + let __v_7: G = G::from_u64(142); + let __v_8: G = G::from_u64(54); + let __v_9: G = G::from_u64(62); + let __v_10: G = G::from_u64(223); + let __v_11: G = G::from_u64(153); + let __v_12: G = G::from_u64(7); + let __v_13: G = G::from_u64(208); + let __v_14: G = G::from_u64(194); + let __v_15: G = G::from_u64(196); + let __v_16: G = G::from_u64(84); + let __v_17: G = G::from_u64(173); + let __v_18: G = G::from_u64(212); + let __v_19: G = G::from_u64(22); + let __v_20: G = G::from_u64(221); + let __v_21: G = G::from_u64(191); + let __v_22: G = G::from_u64(37); + let __v_23: G = G::from_u64(179); + let __v_24: G = G::from_u64(140); + let __v_25: G = G::from_u64(118); + let __v_26: G = G::from_u64(208); + let __v_27: G = G::from_u64(6); + let __v_28: G = G::from_u64(58); + let __v_29: G = G::from_u64(210); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(101); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_210] = [__v_32]; if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20540,38 +20254,38 @@ fn aiur_fn_211( unconstrained: bool, ) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(213); - let __v_1: G = G::from_u64(84); - let __v_2: G = G::from_u64(41); - let __v_3: G = G::from_u64(114); - let __v_4: G = G::from_u64(90); - let __v_5: G = G::from_u64(25); - let __v_6: G = G::from_u64(193); - let __v_7: G = G::from_u64(131); - let __v_8: G = G::from_u64(123); - let __v_9: G = G::from_u64(52); - let __v_10: G = G::from_u64(98); - let __v_11: G = G::from_u64(79); - let __v_12: G = G::from_u64(179); - let __v_13: G = G::from_u64(87); - let __v_14: G = G::from_u64(132); - let __v_15: G = G::from_u64(185); - let __v_16: G = G::from_u64(27); - let __v_17: G = G::from_u64(200); - let __v_18: G = G::from_u64(176); - let __v_19: G = G::from_u64(226); - let __v_20: G = G::from_u64(215); - let __v_21: G = G::from_u64(159); - let __v_22: G = G::from_u64(152); - let __v_23: G = G::from_u64(179); - let __v_24: G = G::from_u64(194); - let __v_25: G = G::from_u64(150); - let __v_26: G = G::from_u64(49); - let __v_27: G = G::from_u64(127); - let __v_28: G = G::from_u64(182); - let __v_29: G = G::from_u64(197); - let __v_30: G = G::from_u64(199); - let __v_31: G = G::from_u64(137); + let __v_0: G = G::from_u64(239); + let __v_1: G = G::from_u64(78); + let __v_2: G = G::from_u64(116); + let __v_3: G = G::from_u64(228); + let __v_4: G = G::from_u64(78); + let __v_5: G = G::from_u64(59); + let __v_6: G = G::from_u64(185); + let __v_7: G = G::from_u64(250); + let __v_8: G = G::from_u64(94); + let __v_9: G = G::from_u64(84); + let __v_10: G = G::from_u64(136); + let __v_11: G = G::from_u64(164); + let __v_12: G = G::from_u64(108); + let __v_13: G = G::from_u64(91); + let __v_14: G = G::from_u64(77); + let __v_15: G = G::from_u64(97); + let __v_16: G = G::from_u64(251); + let __v_17: G = G::from_u64(253); + let __v_18: G = G::from_u64(112); + let __v_19: G = G::from_u64(30); + let __v_20: G = G::from_u64(54); + let __v_21: G = G::from_u64(121); + let __v_22: G = G::from_u64(197); + let __v_23: G = G::from_u64(191); + let __v_24: G = G::from_u64(180); + let __v_25: G = G::from_u64(21); + let __v_26: G = G::from_u64(76); + let __v_27: G = G::from_u64(135); + let __v_28: G = G::from_u64(71); + let __v_29: G = G::from_u64(206); + let __v_30: G = G::from_u64(253); + let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_211] = [__v_32]; if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20589,38 +20303,38 @@ fn aiur_fn_212( unconstrained: bool, ) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(63); - let __v_1: G = G::from_u64(146); - let __v_2: G = G::from_u64(164); - let __v_3: G = G::from_u64(106); - let __v_4: G = G::from_u64(20); - let __v_5: G = G::from_u64(81); - let __v_6: G = G::from_u64(253); - let __v_7: G = G::from_u64(102); - let __v_8: G = G::from_u64(33); - let __v_9: G = G::from_u64(90); - let __v_10: G = G::from_u64(174); - let __v_11: G = G::from_u64(156); - let __v_12: G = G::from_u64(247); - let __v_13: G = G::from_u64(137); - let __v_14: G = G::from_u64(206); - let __v_15: G = G::from_u64(56); - let __v_16: G = G::from_u64(162); - let __v_17: G = G::from_u64(199); - let __v_18: G = G::from_u64(63); - let __v_19: G = G::from_u64(221); - let __v_20: G = G::from_u64(85); - let __v_21: G = G::from_u64(144); - let __v_22: G = G::from_u64(157); - let __v_23: G = G::from_u64(69); - let __v_24: G = G::from_u64(79); - let __v_25: G = G::from_u64(97); - let __v_26: G = G::from_u64(37); - let __v_27: G = G::from_u64(150); - let __v_28: G = G::from_u64(52); - let __v_29: G = G::from_u64(217); - let __v_30: G = G::from_u64(11); - let __v_31: G = G::from_u64(107); + let __v_0: G = G::from_u64(135); + let __v_1: G = G::from_u64(9); + let __v_2: G = G::from_u64(245); + let __v_3: G = G::from_u64(112); + let __v_4: G = G::from_u64(168); + let __v_5: G = G::from_u64(25); + let __v_6: G = G::from_u64(50); + let __v_7: G = G::from_u64(82); + let __v_8: G = G::from_u64(24); + let __v_9: G = G::from_u64(42); + let __v_10: G = G::from_u64(158); + let __v_11: G = G::from_u64(205); + let __v_12: G = G::from_u64(113); + let __v_13: G = G::from_u64(63); + let __v_14: G = G::from_u64(137); + let __v_15: G = G::from_u64(14); + let __v_16: G = G::from_u64(117); + let __v_17: G = G::from_u64(211); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(181); + let __v_20: G = G::from_u64(162); + let __v_21: G = G::from_u64(127); + let __v_22: G = G::from_u64(91); + let __v_23: G = G::from_u64(145); + let __v_24: G = G::from_u64(129); + let __v_25: G = G::from_u64(204); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(224); + let __v_28: G = G::from_u64(101); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(12); + let __v_31: G = G::from_u64(41); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_212] = [__v_32]; if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20638,38 +20352,38 @@ fn aiur_fn_213( unconstrained: bool, ) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(162); - let __v_1: G = G::from_u64(163); - let __v_2: G = G::from_u64(16); - let __v_3: G = G::from_u64(19); - let __v_4: G = G::from_u64(61); - let __v_5: G = G::from_u64(23); - let __v_6: G = G::from_u64(55); - let __v_7: G = G::from_u64(26); - let __v_8: G = G::from_u64(246); - let __v_9: G = G::from_u64(124); - let __v_10: G = G::from_u64(217); - let __v_11: G = G::from_u64(29); - let __v_12: G = G::from_u64(39); - let __v_13: G = G::from_u64(154); - let __v_14: G = G::from_u64(175); - let __v_15: G = G::from_u64(115); - let __v_16: G = G::from_u64(95); - let __v_17: G = G::from_u64(168); - let __v_18: G = G::from_u64(203); - let __v_19: G = G::from_u64(129); - let __v_20: G = G::from_u64(12); - let __v_21: G = G::from_u64(57); - let __v_22: G = G::from_u64(170); - let __v_23: G = G::from_u64(168); - let __v_24: G = G::from_u64(36); - let __v_25: G = G::from_u64(164); - let __v_26: G = G::from_u64(67); - let __v_27: G = G::from_u64(198); - let __v_28: G = G::from_u64(82); - let __v_29: G = G::from_u64(227); - let __v_30: G = G::from_u64(223); - let __v_31: G = G::from_u64(102); + let __v_0: G = G::from_u64(13); + let __v_1: G = G::from_u64(35); + let __v_2: G = G::from_u64(99); + let __v_3: G = G::from_u64(214); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(92); + let __v_6: G = G::from_u64(199); + let __v_7: G = G::from_u64(192); + let __v_8: G = G::from_u64(51); + let __v_9: G = G::from_u64(31); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(92); + let __v_12: G = G::from_u64(161); + let __v_13: G = G::from_u64(222); + let __v_14: G = G::from_u64(123); + let __v_15: G = G::from_u64(64); + let __v_16: G = G::from_u64(145); + let __v_17: G = G::from_u64(37); + let __v_18: G = G::from_u64(27); + let __v_19: G = G::from_u64(80); + let __v_20: G = G::from_u64(77); + let __v_21: G = G::from_u64(68); + let __v_22: G = G::from_u64(238); + let __v_23: G = G::from_u64(178); + let __v_24: G = G::from_u64(133); + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(147); + let __v_27: G = G::from_u64(189); + let __v_28: G = G::from_u64(13); + let __v_29: G = G::from_u64(221); + let __v_30: G = G::from_u64(226); + let __v_31: G = G::from_u64(34); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_213] = [__v_32]; if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20687,38 +20401,38 @@ fn aiur_fn_214( unconstrained: bool, ) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(173); - let __v_1: G = G::from_u64(112); - let __v_2: G = G::from_u64(12); - let __v_3: G = G::from_u64(8); - let __v_4: G = G::from_u64(6); - let __v_5: G = G::from_u64(230); - let __v_6: G = G::from_u64(115); - let __v_7: G = G::from_u64(231); - let __v_8: G = G::from_u64(74); - let __v_9: G = G::from_u64(220); - let __v_10: G = G::from_u64(175); - let __v_11: G = G::from_u64(194); - let __v_12: G = G::from_u64(140); - let __v_13: G = G::from_u64(166); - let __v_14: G = G::from_u64(89); - let __v_15: G = G::from_u64(211); - let __v_16: G = G::from_u64(10); - let __v_17: G = G::from_u64(97); - let __v_18: G = G::from_u64(102); - let __v_19: G = G::from_u64(51); - let __v_20: G = G::from_u64(164); - let __v_21: G = G::from_u64(163); - let __v_22: G = G::from_u64(100); - let __v_23: G = G::from_u64(32); - let __v_24: G = G::from_u64(50); - let __v_25: G = G::from_u64(79); - let __v_26: G = G::from_u64(194); - let __v_27: G = G::from_u64(158); - let __v_28: G = G::from_u64(174); - let __v_29: G = G::from_u64(105); - let __v_30: G = G::from_u64(235); - let __v_31: G = G::from_u64(156); + let __v_0: G = G::from_u64(20); + let __v_1: G = G::from_u64(207); + let __v_2: G = G::from_u64(81); + let __v_3: G = G::from_u64(155); + let __v_4: G = G::from_u64(5); + let __v_5: G = G::from_u64(195); + let __v_6: G = G::from_u64(3); + let __v_7: G = G::from_u64(132); + let __v_8: G = G::from_u64(253); + let __v_9: G = G::from_u64(76); + let __v_10: G = G::from_u64(178); + let __v_11: G = G::from_u64(226); + let __v_12: G = G::from_u64(113); + let __v_13: G = G::from_u64(176); + let __v_14: G = G::from_u64(137); + let __v_15: G = G::from_u64(111); + let __v_16: G = G::from_u64(226); + let __v_17: G = G::from_u64(62); + let __v_18: G = G::from_u64(116); + let __v_19: G = G::from_u64(201); + let __v_20: G = G::from_u64(149); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(13); + let __v_23: G = G::from_u64(66); + let __v_24: G = G::from_u64(235); + let __v_25: G = G::from_u64(31); + let __v_26: G = G::from_u64(252); + let __v_27: G = G::from_u64(225); + let __v_28: G = G::from_u64(73); + let __v_29: G = G::from_u64(39); + let __v_30: G = G::from_u64(229); + let __v_31: G = G::from_u64(107); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_214] = [__v_32]; if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20736,38 +20450,38 @@ fn aiur_fn_215( unconstrained: bool, ) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(216); - let __v_1: G = G::from_u64(56); - let __v_2: G = G::from_u64(187); - let __v_3: G = G::from_u64(107); - let __v_4: G = G::from_u64(182); - let __v_5: G = G::from_u64(81); - let __v_6: G = G::from_u64(83); - let __v_7: G = G::from_u64(48); - let __v_8: G = G::from_u64(129); - let __v_9: G = G::from_u64(172); - let __v_10: G = G::from_u64(36); - let __v_11: G = G::from_u64(149); - let __v_12: G = G::from_u64(162); - let __v_13: G = G::from_u64(93); - let __v_14: G = G::from_u64(105); - let __v_15: G = G::from_u64(12); - let __v_16: G = G::from_u64(84); - let __v_17: G = G::from_u64(248); - let __v_18: G = G::from_u64(227); - let __v_19: G = G::from_u64(69); - let __v_20: G = G::from_u64(255); - let __v_21: G = G::from_u64(244); - let __v_22: G = G::from_u64(30); - let __v_23: G = G::from_u64(251); - let __v_24: G = G::from_u64(213); - let __v_25: G = G::from_u64(88); - let __v_26: G = G::from_u64(94); - let __v_27: G = G::from_u64(180); - let __v_28: G = G::from_u64(104); - let __v_29: G = G::from_u64(112); - let __v_30: G = G::from_u64(83); - let __v_31: G = G::from_u64(8); + let __v_0: G = G::from_u64(253); + let __v_1: G = G::from_u64(83); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(220); + let __v_4: G = G::from_u64(232); + let __v_5: G = G::from_u64(45); + let __v_6: G = G::from_u64(86); + let __v_7: G = G::from_u64(139); + let __v_8: G = G::from_u64(86); + let __v_9: G = G::from_u64(233); + let __v_10: G = G::from_u64(177); + let __v_11: G = G::from_u64(108); + let __v_12: G = G::from_u64(57); + let __v_13: G = G::from_u64(11); + let __v_14: G = G::from_u64(86); + let __v_15: G = G::from_u64(147); + let __v_16: G = G::from_u64(193); + let __v_17: G = G::from_u64(55); + let __v_18: G = G::from_u64(180); + let __v_19: G = G::from_u64(229); + let __v_20: G = G::from_u64(77); + let __v_21: G = G::from_u64(18); + let __v_22: G = G::from_u64(172); + let __v_23: G = G::from_u64(9); + let __v_24: G = G::from_u64(170); + let __v_25: G = G::from_u64(85); + let __v_26: G = G::from_u64(152); + let __v_27: G = G::from_u64(99); + let __v_28: G = G::from_u64(149); + let __v_29: G = G::from_u64(75); + let __v_30: G = G::from_u64(101); + let __v_31: G = G::from_u64(135); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_215] = [__v_32]; if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20775,8 +20489,8 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 0; -const IN_216: usize = 0; +const INPUT_SIZE_216: usize = 1; +const IN_216: usize = 1; const OUT_216: usize = 1; fn aiur_fn_216( inp: [G; IN_216], @@ -20784,193 +20498,95 @@ fn aiur_fn_216( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_216], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(214); - let __v_1: G = G::from_u64(22); - let __v_2: G = G::from_u64(50); - let __v_3: G = G::from_u64(125); - let __v_4: G = G::from_u64(79); - let __v_5: G = G::from_u64(194); - let __v_6: G = G::from_u64(25); - let __v_7: G = G::from_u64(189); - let __v_8: G = G::from_u64(113); - let __v_9: G = G::from_u64(20); - let __v_10: G = G::from_u64(186); - let __v_11: G = G::from_u64(212); - let __v_12: G = G::from_u64(108); - let __v_13: G = G::from_u64(208); - let __v_14: G = G::from_u64(134); - let __v_15: G = G::from_u64(107); - let __v_16: G = G::from_u64(239); - let __v_17: G = G::from_u64(226); - let __v_18: G = G::from_u64(85); - let __v_19: G = G::from_u64(21); - let __v_20: G = G::from_u64(24); - let __v_21: G = G::from_u64(181); - let __v_22: G = G::from_u64(191); - let __v_23: G = G::from_u64(46); - let __v_24: G = G::from_u64(16); - let __v_25: G = G::from_u64(181); - let __v_26: G = G::from_u64(202); - let __v_27: G = G::from_u64(201); - let __v_28: G = G::from_u64(51); - let __v_29: G = G::from_u64(129); - let __v_30: G = G::from_u64(251); - let __v_31: G = G::from_u64(119); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_217: usize = 0; -const IN_217: usize = 0; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(66); - let __v_1: G = G::from_u64(136); - let __v_2: G = G::from_u64(249); - let __v_3: G = G::from_u64(46); - let __v_4: G = G::from_u64(209); - let __v_5: G = G::from_u64(213); - let __v_6: G = G::from_u64(31); - let __v_7: G = G::from_u64(73); - let __v_8: G = G::from_u64(53); - let __v_9: G = G::from_u64(229); - let __v_10: G = G::from_u64(210); - let __v_11: G = G::from_u64(119); - let __v_12: G = G::from_u64(95); - let __v_13: G = G::from_u64(51); - let __v_14: G = G::from_u64(236); - let __v_15: G = G::from_u64(88); - let __v_16: G = G::from_u64(93); - let __v_17: G = G::from_u64(111); - let __v_18: G = G::from_u64(229); - let __v_19: G = G::from_u64(236); - let __v_20: G = G::from_u64(99); - let __v_21: G = G::from_u64(218); - let __v_22: G = G::from_u64(223); - let __v_23: G = G::from_u64(14); - let __v_24: G = G::from_u64(166); - let __v_25: G = G::from_u64(152); - let __v_26: G = G::from_u64(85); - let __v_27: G = G::from_u64(68); - let __v_28: G = G::from_u64(120); - let __v_29: G = G::from_u64(253); - let __v_30: G = G::from_u64(159); - let __v_31: G = G::from_u64(173); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_32]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_218: usize = 1; -const IN_218: usize = 1; -const OUT_218: usize = 1; -fn aiur_fn_218( - inp: [G; IN_218], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_3]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_3]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_5]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_5]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_7]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_7]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_9]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_9]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_11]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_11]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_13]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_13]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_218] = [__v_15]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_15]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_218] = [__v_15]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_15]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20989,33 +20605,33 @@ fn aiur_fn_218( }) } -const INPUT_SIZE_219: usize = 3; -const IN_219: usize = 3; -const OUT_219: usize = 2; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_217: usize = 3; +const IN_217: usize = 3; +const OUT_217: usize = 2; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -21025,8 +20641,8 @@ fn aiur_fn_219( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -21035,8 +20651,8 @@ fn aiur_fn_219( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21050,16 +20666,16 @@ fn aiur_fn_219( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -21072,13 +20688,13 @@ fn aiur_fn_219( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -21089,17 +20705,17 @@ fn aiur_fn_219( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21108,8 +20724,8 @@ fn aiur_fn_219( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21120,8 +20736,8 @@ fn aiur_fn_219( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21129,65 +20745,65 @@ fn aiur_fn_219( } }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_219] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_219] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_219] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_219] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -21200,16 +20816,16 @@ fn aiur_fn_219( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -21229,15 +20845,15 @@ fn aiur_fn_219( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21246,8 +20862,8 @@ fn aiur_fn_219( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21258,8 +20874,8 @@ fn aiur_fn_219( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21270,8 +20886,8 @@ fn aiur_fn_219( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21282,8 +20898,8 @@ fn aiur_fn_219( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21296,8 +20912,8 @@ fn aiur_fn_219( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21316,18 +20932,18 @@ fn aiur_fn_219( }) } -const INPUT_SIZE_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 2; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_218: usize = 1; +const IN_218: usize = 1; +const OUT_218: usize = 2; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21338,13 +20954,13 @@ fn aiur_fn_220( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -21355,16 +20971,16 @@ fn aiur_fn_220( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); @@ -21375,8 +20991,8 @@ fn aiur_fn_220( let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21385,8 +21001,8 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21397,8 +21013,8 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21407,18 +21023,18 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 1; -const IN_221: usize = 1; -const OUT_221: usize = 2; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_219: usize = 1; +const IN_219: usize = 1; +const OUT_219: usize = 2; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21429,13 +21045,13 @@ fn aiur_fn_221( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -21454,15 +21070,15 @@ fn aiur_fn_221( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13, __v_20]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21471,8 +21087,8 @@ fn aiur_fn_221( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21483,8 +21099,8 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21495,8 +21111,8 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21505,15 +21121,15 @@ fn aiur_fn_221( }) } -const INPUT_SIZE_222: usize = 1; -const IN_222: usize = 1; -const OUT_222: usize = 0; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_220: usize = 1; +const IN_220: usize = 1; +const OUT_220: usize = 0; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -21522,17 +21138,17 @@ fn aiur_fn_222( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_222] = []; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = []; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_222] = []; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_220] = []; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21542,35 +21158,35 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 1; -const IN_223: usize = 1; -const OUT_223: usize = 1; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_221: usize = 1; +const IN_221: usize = 1; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_223] = [__v_2]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_2]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_224: usize = 2; -const IN_224: usize = 2; -const OUT_224: usize = 1; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_222: usize = 2; +const IN_222: usize = 2; +const OUT_222: usize = 1; +fn aiur_fn_222( + inp: [G; IN_222], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21580,18 +21196,18 @@ fn aiur_fn_224( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_224] = [__v_1]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_1]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_224] = [__v_7]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_7]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21601,15 +21217,15 @@ fn aiur_fn_224( }) } -const INPUT_SIZE_225: usize = 1; -const IN_225: usize = 1; -const OUT_225: usize = 1; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_223: usize = 1; +const IN_223: usize = 1; +const OUT_223: usize = 1; +fn aiur_fn_223( + inp: [G; IN_223], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); @@ -21622,8 +21238,8 @@ fn aiur_fn_225( 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_225] = [__v_6]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_6]; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21638,15 +21254,15 @@ fn aiur_fn_225( }) } -const INPUT_SIZE_226: usize = 2; -const IN_226: usize = 2; -const OUT_226: usize = 2; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_224: usize = 2; +const IN_224: usize = 2; +const OUT_224: usize = 2; +fn aiur_fn_224( + inp: [G; IN_224], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21654,8 +21270,8 @@ fn aiur_fn_226( let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_226] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21677,11 +21293,11 @@ fn aiur_fn_226( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_226] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21710,11 +21326,11 @@ fn aiur_fn_226( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21722,8 +21338,8 @@ fn aiur_fn_226( let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_226] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_25, __v_15]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21764,15 +21380,15 @@ fn aiur_fn_226( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21781,8 +21397,8 @@ fn aiur_fn_226( let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_226] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_32, __v_18]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21818,15 +21434,15 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: usize = 1; -const OUT_227: usize = 1; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_225: usize = 1; +const IN_225: usize = 1; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21838,17 +21454,17 @@ fn aiur_fn_227( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -21856,7 +21472,7 @@ fn aiur_fn_227( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); @@ -21864,7 +21480,7 @@ fn aiur_fn_227( let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -21877,26 +21493,26 @@ fn aiur_fn_227( let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_227] = [__v_47]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_47]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_228: usize = 4; -const IN_228: usize = 4; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_226: usize = 4; +const IN_226: usize = 4; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21908,15 +21524,15 @@ fn aiur_fn_228( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_228] = [__v_1]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_1]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -21928,13 +21544,13 @@ fn aiur_fn_228( let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_23]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_23]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21944,15 +21560,15 @@ fn aiur_fn_228( }) } -const INPUT_SIZE_229: usize = 2; -const IN_229: usize = 2; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21970,7 +21586,7 @@ fn aiur_fn_229( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -21990,7 +21606,7 @@ fn aiur_fn_229( 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_335] = { let __args: [G; IN_335] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -22000,58 +21616,58 @@ fn aiur_fn_229( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_229] = [__v_33]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_33]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_229] = [__v_34]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_34]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_229] = [__v_0]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_229] = [__v_0]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_229] = [__v_0]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_230: usize = 2; -const IN_230: usize = 2; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_228: usize = 2; +const IN_228: usize = 2; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22064,75 +21680,75 @@ fn aiur_fn_230( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_7]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_7]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_0]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_0]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_231: usize = 1; -const IN_231: usize = 1; -const OUT_231: usize = 4; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_229: usize = 1; +const IN_229: usize = 1; +const OUT_229: usize = 4; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_231], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_231] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_2, __v_5, __v_8, __v_11]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_232: usize = 1; -const IN_232: usize = 1; -const OUT_232: usize = 1; -fn aiur_fn_232( - inp: [G; IN_232], +const INPUT_SIZE_230: usize = 1; +const IN_230: usize = 1; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_232], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -22166,29 +21782,29 @@ fn aiur_fn_232( let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_232] = [__v_31]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_31]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_233: usize = 2; -const IN_233: usize = 2; -const OUT_233: usize = 2; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_231: usize = 2; +const IN_231: usize = 2; +const OUT_231: usize = 2; +fn aiur_fn_231( + inp: [G; IN_231], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22198,13 +21814,13 @@ fn aiur_fn_233( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -22212,8 +21828,8 @@ fn aiur_fn_233( 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_233] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22221,16 +21837,16 @@ fn aiur_fn_233( 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_233] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { @@ -22238,19 +21854,19 @@ fn aiur_fn_233( 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_233] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -22259,30 +21875,30 @@ fn aiur_fn_233( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_233] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_18, __v_21]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_22, __v_21]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_233] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22300,8 +21916,8 @@ fn aiur_fn_233( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_233] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_14, __v_17]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22315,59 +21931,59 @@ fn aiur_fn_233( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_233] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_234: usize = 2; -const IN_234: usize = 2; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 2; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], ExecError> { +) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_234] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_4, __v_3]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_234] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_235: usize = 1; -const IN_235: usize = 1; -const OUT_235: usize = 2; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +const OUT_233: usize = 2; +fn aiur_fn_233( + inp: [G; IN_233], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22384,16 +22000,16 @@ fn aiur_fn_235( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22406,18 +22022,18 @@ fn aiur_fn_235( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_235] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22425,8 +22041,8 @@ fn aiur_fn_235( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22436,8 +22052,8 @@ fn aiur_fn_235( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22445,23 +22061,23 @@ fn aiur_fn_235( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_236: usize = 1; -const IN_236: usize = 1; -const OUT_236: usize = 2; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_234: usize = 1; +const IN_234: usize = 1; +const OUT_234: usize = 2; +fn aiur_fn_234( + inp: [G; IN_234], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -22499,8 +22115,8 @@ fn aiur_fn_236( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22515,8 +22131,8 @@ fn aiur_fn_236( match __v_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_236] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_34, __v_31]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22526,8 +22142,8 @@ fn aiur_fn_236( 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22536,15 +22152,15 @@ fn aiur_fn_236( match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_236] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_38, __v_31]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_38, __v_39]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22558,8 +22174,8 @@ fn aiur_fn_236( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22567,23 +22183,23 @@ fn aiur_fn_236( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_237: usize = 2; -const IN_237: usize = 2; -const OUT_237: usize = 2; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 2; +fn aiur_fn_235( + inp: [G; IN_235], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22591,8 +22207,8 @@ fn aiur_fn_237( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_237] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22600,59 +22216,59 @@ fn aiur_fn_237( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_237] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_238: usize = 1; -const IN_238: usize = 1; -const OUT_238: usize = 4; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_236: usize = 1; +const IN_236: usize = 1; +const OUT_236: usize = 4; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], ExecError> { +) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_238] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_2, __v_5, __v_8, __v_9]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_239: usize = 2; -const IN_239: usize = 2; -const OUT_239: usize = 1; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_237: usize = 2; +const IN_237: usize = 2; +const OUT_237: usize = 1; +fn aiur_fn_237( + inp: [G; IN_237], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -22707,8 +22323,8 @@ fn aiur_fn_239( 1u64 => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_38]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22724,8 +22340,8 @@ fn aiur_fn_239( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_46]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_46]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22745,8 +22361,8 @@ fn aiur_fn_239( let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_52]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_52]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22766,8 +22382,8 @@ fn aiur_fn_239( let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_56]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_56]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22778,212 +22394,212 @@ fn aiur_fn_239( }) } -const INPUT_SIZE_240: usize = 1; -const IN_240: usize = 1; -const OUT_240: usize = 1; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_238: usize = 1; +const IN_238: usize = 1; +const OUT_238: usize = 1; +fn aiur_fn_238( + inp: [G; IN_238], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_3]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_3]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_5]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_5]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_7]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_7]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_9]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_9]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_11]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_13]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_13]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_15]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_15]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_17]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_17]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_19]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_19]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_21]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_21]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_23]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_23]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_25]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_25]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_27]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_27]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_29]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_29]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_31]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_31]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_33]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_33]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_240] = [__v_33]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_33]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23020,56 +22636,56 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 1; -const IN_241: usize = 1; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 1; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); @@ -23080,21 +22696,21 @@ fn aiur_fn_241( let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); - let __ret: [G; OUT_241] = [__v_29]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_29]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 2; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_240: usize = 1; +const IN_240: usize = 1; +const OUT_240: usize = 2; +fn aiur_fn_240( + inp: [G; IN_240], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -23107,8 +22723,8 @@ fn aiur_fn_242( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_242] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_3]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23116,16 +22732,16 @@ fn aiur_fn_242( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -23133,8 +22749,8 @@ fn aiur_fn_242( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23142,18 +22758,18 @@ fn aiur_fn_242( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_242] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23161,23 +22777,23 @@ fn aiur_fn_242( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_243: usize = 2; -const IN_243: usize = 2; -const OUT_243: usize = 2; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_241: usize = 2; +const IN_241: usize = 2; +const OUT_241: usize = 2; +fn aiur_fn_241( + inp: [G; IN_241], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23188,22 +22804,22 @@ fn aiur_fn_243( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_243] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23211,8 +22827,8 @@ fn aiur_fn_243( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_10, __v_13]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23222,8 +22838,8 @@ fn aiur_fn_243( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_8, __v_11]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23233,44 +22849,44 @@ fn aiur_fn_243( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_244: usize = 1; -const IN_244: usize = 1; -const OUT_244: usize = 1; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_242: usize = 1; +const IN_242: usize = 1; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_4]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_4]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_245: usize = 1; -const IN_245: usize = 1; -const OUT_245: usize = 3; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 3; +fn aiur_fn_243( + inp: [G; IN_243], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -23287,40 +22903,40 @@ fn aiur_fn_245( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_15, __v_16, __v_18]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_15, __v_16, __v_18]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23329,8 +22945,8 @@ fn aiur_fn_245( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_15, __v_16, __v_19]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_15, __v_16, __v_19]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23343,8 +22959,8 @@ fn aiur_fn_245( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_11, __v_12, __v_15]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_11, __v_12, __v_15]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23355,8 +22971,8 @@ fn aiur_fn_245( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23367,41 +22983,41 @@ fn aiur_fn_245( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_246: usize = 2; -const IN_246: usize = 2; -const OUT_246: usize = 1; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_244: usize = 2; +const IN_244: usize = 2; +const OUT_244: usize = 1; +fn aiur_fn_244( + inp: [G; IN_244], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -23413,9 +23029,9 @@ fn aiur_fn_246( break '__mc_1 [__v_2]; }, _ => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, @@ -23429,25 +23045,25 @@ fn aiur_fn_246( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_18]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_18]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_247: usize = 4; -const IN_247: usize = 4; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_245: usize = 4; +const IN_245: usize = 4; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23456,34 +23072,34 @@ fn aiur_fn_247( let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_6]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_6]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_7]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_7]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_7]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_7]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23492,54 +23108,54 @@ fn aiur_fn_247( }) } -const INPUT_SIZE_248: usize = 3; -const IN_248: usize = 3; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_246: usize = 3; +const IN_246: usize = 3; +const OUT_246: usize = 1; +fn aiur_fn_246( + inp: [G; IN_246], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_4]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_4]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_11]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_11]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_10]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_10]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23548,21 +23164,21 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 4; -const IN_249: usize = 4; -const OUT_249: usize = 1; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_247: usize = 4; +const IN_247: usize = 4; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -23570,25 +23186,25 @@ fn aiur_fn_249( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_9]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_9]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -23604,54 +23220,54 @@ fn aiur_fn_249( let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_21]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_21]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_250: usize = 3; -const IN_250: usize = 3; -const OUT_250: usize = 1; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_248: usize = 3; +const IN_248: usize = 3; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_4]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_4]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23674,29 +23290,29 @@ fn aiur_fn_250( let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_28]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_27]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_27]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23705,20 +23321,20 @@ fn aiur_fn_250( }) } -const INPUT_SIZE_251: usize = 3; -const IN_251: usize = 3; -const OUT_251: usize = 1; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_249: usize = 3; +const IN_249: usize = 3; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: [G; IN_249], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { @@ -23726,23 +23342,23 @@ fn aiur_fn_251( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_8]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_8]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23752,16 +23368,16 @@ fn aiur_fn_251( } }; let __v_9: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -23772,7 +23388,7 @@ fn aiur_fn_251( }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); @@ -23789,18 +23405,18 @@ fn aiur_fn_251( let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_36]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_36]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23818,10 +23434,10 @@ fn aiur_fn_251( let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_50]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_50]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23830,30 +23446,30 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 3; -const IN_252: usize = 3; -const OUT_252: usize = 2; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_250: usize = 3; +const IN_250: usize = 3; +const OUT_250: usize = 2; +fn aiur_fn_250( + inp: [G; IN_250], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -23867,27 +23483,27 @@ fn aiur_fn_252( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_252] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23895,11 +23511,11 @@ fn aiur_fn_252( let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23908,12 +23524,12 @@ fn aiur_fn_252( let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23922,8 +23538,8 @@ fn aiur_fn_252( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_252] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23940,25 +23556,25 @@ fn aiur_fn_252( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_252] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_252] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23967,8 +23583,8 @@ fn aiur_fn_252( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_252] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23979,62 +23595,62 @@ fn aiur_fn_252( }) } -const INPUT_SIZE_253: usize = 4; -const IN_253: usize = 4; -const OUT_253: usize = 2; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_251: usize = 4; +const IN_251: usize = 4; +const OUT_251: usize = 2; +fn aiur_fn_251( + inp: [G; IN_251], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -24053,15 +23669,15 @@ fn aiur_fn_253( let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_33 - __v_35); let __v_37: G = (__v_2 * __v_36); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -24072,12 +23688,12 @@ fn aiur_fn_253( let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24086,54 +23702,54 @@ fn aiur_fn_253( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -24143,34 +23759,34 @@ fn aiur_fn_253( let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 * __v_33); let __v_35: G = (__v_27 * __v_34); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -24185,12 +23801,12 @@ fn aiur_fn_253( let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24199,8 +23815,8 @@ fn aiur_fn_253( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24209,15 +23825,15 @@ fn aiur_fn_253( }) } -const INPUT_SIZE_254: usize = 2; -const IN_254: usize = 2; -const OUT_254: usize = 1; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_252: usize = 2; +const IN_252: usize = 2; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: [G; IN_252], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24227,18 +23843,18 @@ fn aiur_fn_254( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_254] = [__v_0]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_0]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_254] = [__v_8]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_8]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24248,264 +23864,264 @@ fn aiur_fn_254( }) } -const INPUT_SIZE_255: usize = 3; -const IN_255: usize = 3; -const OUT_255: usize = 2; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_253: usize = 3; +const IN_253: usize = 3; +const OUT_253: usize = 2; +fn aiur_fn_253( + inp: [G; IN_253], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_11, __v_14]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_29, __v_31]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_31, __v_33]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24514,8 +24130,8 @@ fn aiur_fn_255( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_255] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_31, __v_35]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24548,15 +24164,15 @@ fn aiur_fn_255( }) } -const INPUT_SIZE_256: usize = 2; -const IN_256: usize = 2; -const OUT_256: usize = 3; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_254: usize = 2; +const IN_254: usize = 2; +const OUT_254: usize = 3; +fn aiur_fn_254( + inp: [G; IN_254], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24567,9 +24183,9 @@ fn aiur_fn_256( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -24577,22 +24193,22 @@ fn aiur_fn_256( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_8, __v_0, __v_11]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -24604,8 +24220,8 @@ fn aiur_fn_256( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_256] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_12, __v_17]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24613,8 +24229,8 @@ fn aiur_fn_256( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24624,8 +24240,8 @@ fn aiur_fn_256( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24635,8 +24251,8 @@ fn aiur_fn_256( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24648,23 +24264,23 @@ fn aiur_fn_256( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_6, __v_0, __v_9]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_257: usize = 2; -const IN_257: usize = 2; -const OUT_257: usize = 1; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_255: usize = 2; +const IN_255: usize = 2; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24681,32 +24297,32 @@ fn aiur_fn_257( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_27]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_27]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); @@ -24726,23 +24342,23 @@ fn aiur_fn_257( let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_44]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_44]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 1; -const IN_258: usize = 1; -const OUT_258: usize = 1; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_256: usize = 1; +const IN_256: usize = 1; +const OUT_256: usize = 1; +fn aiur_fn_256( + inp: [G; IN_256], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24752,12 +24368,12 @@ fn aiur_fn_258( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_258] = [__v_0]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24767,41 +24383,41 @@ fn aiur_fn_258( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_258] = [__v_0]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_258] = [__v_16]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_16]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_258] = [__v_0]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_258] = [__v_0]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24810,33 +24426,33 @@ fn aiur_fn_258( }) } -const INPUT_SIZE_259: usize = 3; -const IN_259: usize = 3; -const OUT_259: usize = 2; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_257: usize = 3; +const IN_257: usize = 3; +const OUT_257: usize = 2; +fn aiur_fn_257( + inp: [G; IN_257], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); @@ -24847,30 +24463,30 @@ fn aiur_fn_259( let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_260: usize = 1; -const IN_260: usize = 1; -const OUT_260: usize = 1; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_258: usize = 1; +const IN_258: usize = 1; +const OUT_258: usize = 1; +fn aiur_fn_258( + inp: [G; IN_258], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24887,7 +24503,7 @@ fn aiur_fn_260( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24897,26 +24513,26 @@ fn aiur_fn_260( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_17]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_17]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -24926,22 +24542,22 @@ fn aiur_fn_260( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_260] = [__v_26]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_26]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_26]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_26]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_20]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_20]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24950,39 +24566,39 @@ fn aiur_fn_260( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_15]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_15]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_9]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_9]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_260] = [__v_5]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_5]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_261: usize = 5; -const IN_261: usize = 5; -const OUT_261: usize = 2; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_259: usize = 5; +const IN_259: usize = 5; +const OUT_259: usize = 2; +fn aiur_fn_259( + inp: [G; IN_259], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24998,14 +24614,14 @@ fn aiur_fn_261( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -25015,17 +24631,17 @@ fn aiur_fn_261( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -25034,39 +24650,39 @@ fn aiur_fn_261( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_261] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_261] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25082,28 +24698,28 @@ fn aiur_fn_261( }) } -const INPUT_SIZE_262: usize = 3; -const IN_262: usize = 3; -const OUT_262: usize = 2; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_260: usize = 3; +const IN_260: usize = 3; +const OUT_260: usize = 2; +fn aiur_fn_260( + inp: [G; IN_260], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -25116,31 +24732,31 @@ fn aiur_fn_262( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25149,8 +24765,8 @@ fn aiur_fn_262( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25169,33 +24785,33 @@ fn aiur_fn_262( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25204,8 +24820,8 @@ fn aiur_fn_262( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25213,11 +24829,11 @@ fn aiur_fn_262( } }, _ => { - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_262] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25226,15 +24842,15 @@ fn aiur_fn_262( }) } -const INPUT_SIZE_263: usize = 3; -const IN_263: usize = 3; -const OUT_263: usize = 2; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_261: usize = 3; +const IN_261: usize = 3; +const OUT_261: usize = 2; +fn aiur_fn_261( + inp: [G; IN_261], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25248,40 +24864,40 @@ fn aiur_fn_263( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25290,8 +24906,8 @@ fn aiur_fn_263( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25302,23 +24918,23 @@ fn aiur_fn_263( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_263] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25327,8 +24943,8 @@ fn aiur_fn_263( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25339,43 +24955,43 @@ fn aiur_fn_263( }) } -const INPUT_SIZE_264: usize = 4; -const IN_264: usize = 4; -const OUT_264: usize = 2; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_262: usize = 4; +const IN_262: usize = 4; +const OUT_262: usize = 2; +fn aiur_fn_262( + inp: [G; IN_262], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_14 - __v_17); let __v_19: G = (__v_13 * __v_18); @@ -25388,24 +25004,24 @@ fn aiur_fn_264( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_22, __v_26]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_264] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_26, __v_25]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25414,18 +25030,18 @@ fn aiur_fn_264( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_26, __v_30]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_264] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25434,15 +25050,15 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 4; -const IN_265: usize = 4; -const OUT_265: usize = 1; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_263: usize = 4; +const IN_263: usize = 4; +const OUT_263: usize = 1; +fn aiur_fn_263( + inp: [G; IN_263], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25458,27 +25074,27 @@ fn aiur_fn_265( let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_17]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_17]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_266: usize = 10; -const IN_266: usize = 10; -const OUT_266: usize = 8; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_264: usize = 10; +const IN_264: usize = 10; +const OUT_264: usize = 8; +fn aiur_fn_264( + inp: [G; IN_264], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25492,8 +25108,8 @@ fn aiur_fn_266( let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_266] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25503,15 +25119,15 @@ fn aiur_fn_266( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_266] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25520,13 +25136,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25535,13 +25151,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25550,13 +25166,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25565,13 +25181,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25580,13 +25196,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25595,13 +25211,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25610,13 +25226,13 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25625,8 +25241,8 @@ fn aiur_fn_266( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25640,22 +25256,22 @@ fn aiur_fn_266( }) } -const INPUT_SIZE_267: usize = 2; -const IN_267: usize = 2; -const OUT_267: usize = 1; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_265: usize = 2; +const IN_265: usize = 2; +const OUT_265: usize = 1; +fn aiur_fn_265( + inp: [G; IN_265], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_267] = [__v_0]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_0]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25668,17 +25284,17 @@ fn aiur_fn_267( 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_267] = [__v_7]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_7]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_267] = [__v_7]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_7]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25690,15 +25306,15 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 1; -const IN_268: usize = 1; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_266: usize = 1; +const IN_266: usize = 1; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -25710,7 +25326,7 @@ fn aiur_fn_268( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25720,7 +25336,7 @@ fn aiur_fn_268( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -25734,7 +25350,7 @@ fn aiur_fn_268( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -25754,15 +25370,15 @@ fn aiur_fn_268( let __v_33: G = __loaded[9]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; match __v_34.as_canonical_u64() { 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_37]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_37]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -25771,8 +25387,8 @@ fn aiur_fn_268( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_39]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_39]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25783,23 +25399,23 @@ fn aiur_fn_268( _ => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_35]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_35]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: usize = 1; -const OUT_269: usize = 1; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_267: usize = 1; +const IN_267: usize = 1; +const OUT_267: usize = 1; +fn aiur_fn_267( + inp: [G; IN_267], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; @@ -25817,50 +25433,50 @@ fn aiur_fn_269( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_12]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_12]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_13]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_13]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_13]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_13]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25870,15 +25486,15 @@ fn aiur_fn_269( }) } -const INPUT_SIZE_270: usize = 2; -const IN_270: usize = 2; -const OUT_270: usize = 1; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_268: usize = 2; +const IN_268: usize = 2; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25898,23 +25514,23 @@ fn aiur_fn_270( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_14]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_14]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_17]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_17]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25924,15 +25540,15 @@ fn aiur_fn_270( }) } -const INPUT_SIZE_271: usize = 5; -const IN_271: usize = 5; -const OUT_271: usize = 1; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_269: usize = 5; +const IN_269: usize = 5; +const OUT_269: usize = 1; +fn aiur_fn_269( + inp: [G; IN_269], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25960,158 +25576,158 @@ fn aiur_fn_271( let __v_22: G = __loaded[17]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_28]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_26]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_26]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_28]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_28]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_28]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_29]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_29]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_30]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_30]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_27]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_27]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_27]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_27]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -26119,10 +25735,10 @@ fn aiur_fn_271( let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_271] = [__v_28]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26137,15 +25753,15 @@ fn aiur_fn_271( }) } -const INPUT_SIZE_272: usize = 17; -const IN_272: usize = 17; -const OUT_272: usize = 12; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_270: usize = 17; +const IN_270: usize = 17; +const OUT_270: usize = 12; +fn aiur_fn_270( + inp: [G; IN_270], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26166,18 +25782,18 @@ fn aiur_fn_272( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_272] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -26195,15 +25811,15 @@ fn aiur_fn_272( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_272] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_272] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26215,15 +25831,15 @@ fn aiur_fn_272( }) } -const INPUT_SIZE_273: usize = 14; -const IN_273: usize = 14; -const OUT_273: usize = 12; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_271: usize = 14; +const IN_271: usize = 14; +const OUT_271: usize = 12; +fn aiur_fn_271( + inp: [G; IN_271], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26241,29 +25857,29 @@ fn aiur_fn_273( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_274: usize = 14; -const IN_274: usize = 14; -const OUT_274: usize = 12; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_272: usize = 14; +const IN_272: usize = 14; +const OUT_272: usize = 12; +fn aiur_fn_272( + inp: [G; IN_272], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26281,29 +25897,29 @@ fn aiur_fn_274( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_275: usize = 1; -const IN_275: usize = 1; -const OUT_275: usize = 1; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_273: usize = 1; +const IN_273: usize = 1; +const OUT_273: usize = 1; +fn aiur_fn_273( + inp: [G; IN_273], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -26346,17 +25962,17 @@ fn aiur_fn_275( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_37]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_37]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_275] = [__v_39]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_39]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26366,15 +25982,15 @@ fn aiur_fn_275( }) } -const INPUT_SIZE_276: usize = 2; -const IN_276: usize = 2; -const OUT_276: usize = 34; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_274: usize = 2; +const IN_274: usize = 2; +const OUT_274: usize = 34; +fn aiur_fn_274( + inp: [G; IN_274], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26419,14 +26035,14 @@ fn aiur_fn_276( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_276] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -26461,8 +26077,8 @@ fn aiur_fn_276( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_276] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26474,15 +26090,15 @@ fn aiur_fn_276( }) } -const INPUT_SIZE_277: usize = 33; -const IN_277: usize = 33; -const OUT_277: usize = 12; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_275: usize = 33; +const IN_275: usize = 33; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: [G; IN_275], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26519,35 +26135,35 @@ fn aiur_fn_277( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_277] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_275] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_278: usize = 40; -const IN_278: usize = 40; -const OUT_278: usize = 12; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_276: usize = 40; +const IN_276: usize = 40; +const OUT_276: usize = 12; +fn aiur_fn_276( + inp: [G; IN_276], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26591,35 +26207,35 @@ fn aiur_fn_278( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_278] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_279: usize = 6; -const IN_279: usize = 6; -const OUT_279: usize = 1; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_277: usize = 6; +const IN_277: usize = 6; +const OUT_277: usize = 1; +fn aiur_fn_277( + inp: [G; IN_277], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26644,25 +26260,25 @@ fn aiur_fn_279( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_279] = [__v_19]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_19]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_279] = [__v_23]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_23]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26674,15 +26290,15 @@ fn aiur_fn_279( }) } -const INPUT_SIZE_280: usize = 50; -const IN_280: usize = 50; -const OUT_280: usize = 12; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_278: usize = 50; +const IN_278: usize = 50; +const OUT_278: usize = 12; +fn aiur_fn_278( + inp: [G; IN_278], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26736,39 +26352,39 @@ fn aiur_fn_280( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_280] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_278] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_281: usize = 1; -const IN_281: usize = 1; -const OUT_281: usize = 48; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_279: usize = 1; +const IN_279: usize = 1; +const OUT_279: usize = 48; +fn aiur_fn_279( + inp: [G; IN_279], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -26809,10 +26425,10 @@ fn aiur_fn_281( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -26877,21 +26493,21 @@ fn aiur_fn_281( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_281] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_279] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_282: usize = 1; -const IN_282: usize = 1; -const OUT_282: usize = 1; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_280: usize = 1; +const IN_280: usize = 1; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -26932,7 +26548,7 @@ fn aiur_fn_282( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(3); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -26940,8 +26556,8 @@ fn aiur_fn_282( let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_282] = [__v_39]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_39]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26951,15 +26567,15 @@ fn aiur_fn_282( }) } -const INPUT_SIZE_283: usize = 1; -const IN_283: usize = 1; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_281: usize = 1; +const IN_281: usize = 1; +const OUT_281: usize = 1; +fn aiur_fn_281( + inp: [G; IN_281], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -27000,46 +26616,46 @@ fn aiur_fn_283( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(4); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_283] = [__v_37]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_281] = [__v_37]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_284: usize = 2; -const IN_284: usize = 2; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_282: usize = 2; +const IN_282: usize = 2; +const OUT_282: usize = 1; +fn aiur_fn_282( + inp: [G; IN_282], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_284] = [__v_2]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_284] = [__v_2]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_284] = [__v_2]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27048,14 +26664,14 @@ fn aiur_fn_284( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_284] = [__v_2]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_284] = [__v_2]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27067,15 +26683,15 @@ fn aiur_fn_284( }) } -const INPUT_SIZE_285: usize = 14; -const IN_285: usize = 14; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_283: usize = 14; +const IN_283: usize = 14; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27093,22 +26709,22 @@ fn aiur_fn_285( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_285] = [__v_17]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_17]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_285] = [__v_15]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_15]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27117,18 +26733,18 @@ fn aiur_fn_285( }) } -const INPUT_SIZE_286: usize = 1; -const IN_286: usize = 1; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +const INPUT_SIZE_284: usize = 1; +const IN_284: usize = 1; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_286], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -27181,11 +26797,11 @@ fn aiur_fn_286( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { @@ -27207,7 +26823,7 @@ fn aiur_fn_286( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27221,15 +26837,15 @@ fn aiur_fn_286( let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_63]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_63]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -27243,15 +26859,15 @@ fn aiur_fn_286( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_64]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_64]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -27265,17 +26881,17 @@ fn aiur_fn_286( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_64]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_64]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_49]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_49]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27283,12 +26899,12 @@ fn aiur_fn_286( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_50]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_50]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27296,14 +26912,14 @@ fn aiur_fn_286( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_51]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_51]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27311,12 +26927,12 @@ fn aiur_fn_286( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_50]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_50]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27328,7 +26944,7 @@ fn aiur_fn_286( let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -27342,8 +26958,8 @@ fn aiur_fn_286( let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_67]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_67]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27355,15 +26971,15 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 10; -const IN_287: usize = 10; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_285: usize = 10; +const IN_285: usize = 10; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27375,7 +26991,7 @@ fn aiur_fn_287( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -27428,7 +27044,7 @@ fn aiur_fn_287( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -27476,11 +27092,11 @@ fn aiur_fn_287( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27494,8 +27110,8 @@ fn aiur_fn_287( let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_117]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_117]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27512,19 +27128,19 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 2; -const IN_288: usize = 2; -const OUT_288: usize = 1; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_286: usize = 2; +const IN_286: usize = 2; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27577,7 +27193,7 @@ fn aiur_fn_288( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27625,9 +27241,9 @@ fn aiur_fn_288( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27641,8 +27257,8 @@ fn aiur_fn_288( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_288] = [__v_108]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_108]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27659,20 +27275,20 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 3; -const IN_289: usize = 3; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_287: usize = 3; +const IN_287: usize = 3; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27725,7 +27341,7 @@ fn aiur_fn_289( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27775,7 +27391,7 @@ fn aiur_fn_289( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27810,9 +27426,9 @@ fn aiur_fn_289( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -27826,8 +27442,8 @@ fn aiur_fn_289( let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_289] = [__v_143]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_143]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27846,19 +27462,19 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 2; -const IN_290: usize = 2; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_288: usize = 2; +const IN_288: usize = 2; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: [G; IN_288], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27911,7 +27527,7 @@ fn aiur_fn_290( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27959,9 +27575,9 @@ fn aiur_fn_290( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27975,8 +27591,8 @@ fn aiur_fn_290( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_290] = [__v_108]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_108]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27993,15 +27609,15 @@ fn aiur_fn_290( }) } -const INPUT_SIZE_291: usize = 2; -const IN_291: usize = 2; -const OUT_291: usize = 45; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_289: usize = 2; +const IN_289: usize = 2; +const OUT_289: usize = 45; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28057,14 +27673,14 @@ fn aiur_fn_291( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_291] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -28110,8 +27726,8 @@ fn aiur_fn_291( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_291] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28123,15 +27739,15 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 1; -const IN_292: usize = 1; -const OUT_292: usize = 8; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_290: usize = 1; +const IN_290: usize = 1; +const OUT_290: usize = 8; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -28147,31 +27763,31 @@ fn aiur_fn_292( if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_292] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_290] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_293: usize = 3; -const IN_293: usize = 3; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_291: usize = 3; +const IN_291: usize = 3; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -28217,7 +27833,7 @@ fn aiur_fn_293( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -28306,44 +27922,44 @@ fn aiur_fn_293( let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_114]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_291] = [__v_114]; + if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_294: usize = 2; -const IN_294: usize = 2; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_292: usize = 2; +const IN_292: usize = 2; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_3]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_3]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_295: usize = 4; -const IN_295: usize = 4; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_293: usize = 4; +const IN_293: usize = 4; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28402,21 +28018,21 @@ fn aiur_fn_295( let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_295] = [__v_53]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_53]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_295] = [__v_56]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_56]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28426,15 +28042,15 @@ fn aiur_fn_295( }) } -const INPUT_SIZE_296: usize = 1; -const IN_296: usize = 1; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_294: usize = 1; +const IN_294: usize = 1; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28444,57 +28060,57 @@ fn aiur_fn_296( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_4]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_4]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_4]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_6]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_6]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_6]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_4]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28504,15 +28120,15 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 2; -const IN_297: usize = 2; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_295: usize = 2; +const IN_295: usize = 2; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28529,14 +28145,14 @@ fn aiur_fn_297( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28548,16 +28164,16 @@ fn aiur_fn_297( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28569,19 +28185,19 @@ fn aiur_fn_297( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28593,19 +28209,19 @@ fn aiur_fn_297( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28619,14 +28235,14 @@ fn aiur_fn_297( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_297] = [__v_9]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_9]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28638,15 +28254,15 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_296: usize = 2; +const IN_296: usize = 2; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28663,14 +28279,14 @@ fn aiur_fn_298( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28686,8 +28302,8 @@ fn aiur_fn_298( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28695,8 +28311,8 @@ fn aiur_fn_298( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_9]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_9]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28704,15 +28320,15 @@ fn aiur_fn_298( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28737,15 +28353,15 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 2; -const IN_299: usize = 2; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_297: usize = 2; +const IN_297: usize = 2; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28756,8 +28372,8 @@ fn aiur_fn_299( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_5]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_5]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28768,8 +28384,8 @@ fn aiur_fn_299( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_8]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28777,25 +28393,25 @@ fn aiur_fn_299( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_9]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_9]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_10]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_10]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28820,15 +28436,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_298: usize = 2; +const IN_298: usize = 2; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: [G; IN_298], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28845,14 +28461,14 @@ fn aiur_fn_300( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28868,15 +28484,15 @@ fn aiur_fn_300( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28891,15 +28507,15 @@ fn aiur_fn_300( }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 2; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 2; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28915,8 +28531,8 @@ fn aiur_fn_301( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_301] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_5, __v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28926,8 +28542,8 @@ fn aiur_fn_301( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_301] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28935,18 +28551,18 @@ fn aiur_fn_301( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_7, __v_1]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_301] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28966,15 +28582,15 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 3; -const IN_302: usize = 3; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_300: usize = 3; +const IN_300: usize = 3; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28991,8 +28607,8 @@ fn aiur_fn_302( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_11]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_11]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29007,8 +28623,8 @@ fn aiur_fn_302( let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_11]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_11]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29016,11 +28632,11 @@ fn aiur_fn_302( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_12]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_12]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29030,13 +28646,13 @@ fn aiur_fn_302( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_13]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_13]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_302] = [__v_0]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_0]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29063,15 +28679,15 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29088,14 +28704,14 @@ fn aiur_fn_303( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_303] = [__v_8]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_8]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29111,8 +28727,8 @@ fn aiur_fn_303( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_8]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29132,26 +28748,197 @@ fn aiur_fn_303( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_14]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_14]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_14]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_14]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_303] = [__v_13]; + let __ret: [G; OUT_301] = [__v_13]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_302: usize = 1; +const IN_302: usize = 1; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_302], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_302] = [__v_4]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + match __v_4.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_302] = [__v_5]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_302] = [__v_6]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_303: usize = 2; +const IN_303: usize = 2; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_303], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + match __v_10.as_canonical_u64() { + _ => { + let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_303] = [__v_15]; if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + 0u64 => { + let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_303] = [__v_14]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_303] = [__v_17]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_303] = [__v_15]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, } }, } @@ -29170,8 +28957,8 @@ fn aiur_fn_303( }) } -const INPUT_SIZE_304: usize = 1; -const IN_304: usize = 1; +const INPUT_SIZE_304: usize = 3; +const IN_304: usize = 3; const OUT_304: usize = 1; fn aiur_fn_304( inp: [G; IN_304], @@ -29179,185 +28966,14 @@ fn aiur_fn_304( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_304], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_4]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; - let __v_4: G = __loaded[0]; - let __v_5: G = __loaded[1]; - match __v_4.as_canonical_u64() { - _ => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_7.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_304] = [__v_5]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __ret: [G; OUT_304] = [__v_6]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); - }, - } - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_305: usize = 2; -const IN_305: usize = 2; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_305] = [__v_0]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_5: G = __loaded[0]; - let __v_6: G = __loaded[1]; - let __v_7: G = __loaded[2]; - match __v_5.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_305] = [__v_0]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; - let __v_8: G = __loaded[0]; - let __v_9: G = __loaded[1]; - match __v_8.as_canonical_u64() { - _ => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; - let __v_10: G = __loaded[0]; - let __v_11: G = __loaded[1]; - match __v_10.as_canonical_u64() { - _ => { - let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_12.as_canonical_u64() { - 1u64 => { - let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_15]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_13.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_305] = [__v_14]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_14.as_canonical_u64() { - 1u64 => { - let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_17]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_305] = [__v_15]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); - }, - } - }, - } - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_306: usize = 3; -const IN_306: usize = 3; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { stacker::maybe_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_306] = [__v_0]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_0]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29367,15 +28983,15 @@ fn aiur_fn_306( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_6]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_6]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_306] = [__v_0]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_0]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29384,25 +29000,25 @@ fn aiur_fn_306( } }, _ => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_3]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_3]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_307: usize = 3; -const IN_307: usize = 3; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_305: usize = 3; +const IN_305: usize = 3; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29422,8 +29038,8 @@ fn aiur_fn_307( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_14]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_14]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29433,7 +29049,7 @@ fn aiur_fn_307( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -29443,13 +29059,13 @@ fn aiur_fn_307( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_13]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_13]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_0]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29464,17 +29080,17 @@ fn aiur_fn_307( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_15]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_15]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_12]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_12]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29488,15 +29104,15 @@ fn aiur_fn_307( }) } -const INPUT_SIZE_308: usize = 4; -const IN_308: usize = 4; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_306: usize = 4; +const IN_306: usize = 4; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29521,8 +29137,8 @@ fn aiur_fn_308( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_19]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_19]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29532,17 +29148,17 @@ fn aiur_fn_308( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_14]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_14]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29556,17 +29172,17 @@ fn aiur_fn_308( let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_20]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_20]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_13]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_13]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29580,15 +29196,15 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 4; -const IN_309: usize = 4; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_307: usize = 4; +const IN_307: usize = 4; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29600,63 +29216,63 @@ fn aiur_fn_309( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_7]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_7]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_9]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_8]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_8]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_7]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_7]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_10]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_10]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_309] = [__v_3]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_3]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_9]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29673,15 +29289,15 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 5; -const IN_310: usize = 5; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_308: usize = 5; +const IN_308: usize = 5; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29694,55 +29310,55 @@ fn aiur_fn_310( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_8]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_8]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_11]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_11]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_9]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_9]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_12]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_12]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29751,17 +29367,17 @@ fn aiur_fn_310( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_11]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_11]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29776,15 +29392,15 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 2; -const IN_311: usize = 2; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_309: usize = 2; +const IN_309: usize = 2; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29794,19 +29410,19 @@ fn aiur_fn_311( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_311] = [__v_0]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_0]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_8]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_8]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29816,15 +29432,15 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_310: usize = 2; +const IN_310: usize = 2; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29834,8 +29450,8 @@ fn aiur_fn_312( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_312] = [__v_0]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_0]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29851,18 +29467,18 @@ fn aiur_fn_312( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_12]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_12]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29895,7 +29511,7 @@ fn aiur_fn_312( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -29936,7 +29552,7 @@ fn aiur_fn_312( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29952,10 +29568,10 @@ fn aiur_fn_312( }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_16]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_16]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29971,15 +29587,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 1; -const IN_313: usize = 1; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_311: usize = 1; +const IN_311: usize = 1; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29988,8 +29604,8 @@ fn aiur_fn_313( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_313] = [__v_0]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30007,15 +29623,15 @@ fn aiur_fn_313( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_10]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_313] = [__v_0]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30024,8 +29640,8 @@ fn aiur_fn_313( } }, _ => { - let __ret: [G; OUT_313] = [__v_0]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30039,21 +29655,21 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 2; -const IN_314: usize = 2; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -30068,14 +29684,14 @@ fn aiur_fn_314( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30091,8 +29707,8 @@ fn aiur_fn_314( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30108,27 +29724,27 @@ fn aiur_fn_314( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_19]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_19]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_19]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_19]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30138,16 +29754,16 @@ fn aiur_fn_314( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_18]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_18]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_17]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_17]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30168,15 +29784,15 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 3; -const IN_315: usize = 3; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_313: usize = 3; +const IN_313: usize = 3; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30188,8 +29804,8 @@ fn aiur_fn_315( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_6]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_6]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30199,14 +29815,14 @@ fn aiur_fn_315( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_10]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30217,7 +29833,7 @@ fn aiur_fn_315( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -30230,15 +29846,15 @@ fn aiur_fn_315( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_315] = [__v_12]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_12]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30257,15 +29873,15 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 2; -const IN_316: usize = 2; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_314: usize = 2; +const IN_314: usize = 2; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30276,8 +29892,8 @@ fn aiur_fn_316( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_5]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_5]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30292,15 +29908,15 @@ fn aiur_fn_316( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30317,15 +29933,15 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 4; -const IN_317: usize = 4; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_315: usize = 4; +const IN_315: usize = 4; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30338,8 +29954,8 @@ fn aiur_fn_317( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_7]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_7]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30349,31 +29965,31 @@ fn aiur_fn_317( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_11]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_11]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_12]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_12]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_12]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_12]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30392,15 +30008,15 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 3; -const IN_318: usize = 3; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_316: usize = 3; +const IN_316: usize = 3; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30412,8 +30028,8 @@ fn aiur_fn_318( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_6]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_6]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30429,15 +30045,15 @@ fn aiur_fn_318( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_318] = [__v_10]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_10]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30446,10 +30062,10 @@ fn aiur_fn_318( } }, _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_9]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_9]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30463,15 +30079,15 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 2; -const IN_319: usize = 2; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30482,8 +30098,8 @@ fn aiur_fn_319( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_5]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30499,7 +30115,7 @@ fn aiur_fn_319( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30509,25 +30125,25 @@ fn aiur_fn_319( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_9]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_9]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_10]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_10]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30549,15 +30165,15 @@ fn aiur_fn_319( }) } -const INPUT_SIZE_320: usize = 3; -const IN_320: usize = 3; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_320], +const INPUT_SIZE_318: usize = 3; +const IN_318: usize = 3; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30569,8 +30185,8 @@ fn aiur_fn_320( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_6]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_6]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30579,20 +30195,20 @@ fn aiur_fn_320( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_9]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_9]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_9]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_9]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30609,15 +30225,15 @@ fn aiur_fn_320( }) } -const INPUT_SIZE_321: usize = 1; -const IN_321: usize = 1; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_319: usize = 1; +const IN_319: usize = 1; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -30637,35 +30253,35 @@ fn aiur_fn_321( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_19]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_19]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_322: usize = 2; -const IN_322: usize = 2; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_320: usize = 2; +const IN_320: usize = 2; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_322] = [__v_3]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_3]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30676,19 +30292,19 @@ fn aiur_fn_322( match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_322] = [__v_6]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_6]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_8]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_8]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30700,36 +30316,36 @@ fn aiur_fn_322( }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_321: usize = 2; +const IN_321: usize = 2; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_3]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_3]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_5]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_5]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30739,24 +30355,24 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_322: usize = 2; +const IN_322: usize = 2; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30764,13 +30380,13 @@ fn aiur_fn_324( let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_324] = [__v_1]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_1]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_324] = [__v_0]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_0]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30779,43 +30395,43 @@ fn aiur_fn_324( } }, _ => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_6]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_6]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_4]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_4]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30825,8 +30441,8 @@ fn aiur_fn_325( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_325] = [__v_1]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_1]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30836,33 +30452,33 @@ fn aiur_fn_325( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_1]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_1]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_11]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_11]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30886,15 +30502,15 @@ fn aiur_fn_325( }) } -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30902,8 +30518,8 @@ fn aiur_fn_326( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_326] = [__v_3]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_3]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30920,14 +30536,14 @@ fn aiur_fn_326( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30939,16 +30555,16 @@ fn aiur_fn_326( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30960,19 +30576,19 @@ fn aiur_fn_326( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_326] = [__v_11]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_11]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30984,19 +30600,19 @@ fn aiur_fn_326( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_326] = [__v_11]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_11]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31012,22 +30628,22 @@ fn aiur_fn_326( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_326] = [__v_10]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_10]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_10]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_10]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31041,15 +30657,15 @@ fn aiur_fn_326( }) } -const INPUT_SIZE_327: usize = 2; -const IN_327: usize = 2; -const OUT_327: usize = 1; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31059,20 +30675,20 @@ fn aiur_fn_327( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_6]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_327] = [__v_6]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31082,48 +30698,48 @@ fn aiur_fn_327( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_5]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_5]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 1; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_328] = [__v_1]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_328] = [__v_0]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31134,8 +30750,8 @@ fn aiur_fn_328( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_328] = [__v_10]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_10]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31145,15 +30761,15 @@ fn aiur_fn_328( }) } -const INPUT_SIZE_329: usize = 1; -const IN_329: usize = 1; -const OUT_329: usize = 2; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_327: usize = 1; +const IN_327: usize = 1; +const OUT_327: usize = 2; +fn aiur_fn_327( + inp: [G; IN_327], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -31164,12 +30780,12 @@ fn aiur_fn_329( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_329] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -31177,15 +30793,15 @@ fn aiur_fn_329( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_329] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_329] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31193,23 +30809,23 @@ fn aiur_fn_329( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_329] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_330: usize = 2; -const IN_330: usize = 2; -const OUT_330: usize = 2; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 2; +fn aiur_fn_328( + inp: [G; IN_328], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31221,31 +30837,31 @@ fn aiur_fn_330( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_330] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_330] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_331: usize = 2; -const IN_331: usize = 2; -const OUT_331: usize = 1; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_329: usize = 2; +const IN_329: usize = 2; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31258,26 +30874,26 @@ fn aiur_fn_331( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_7]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_331] = [__v_5]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_5]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_331] = [__v_6]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31287,24 +30903,24 @@ fn aiur_fn_331( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_331] = [__v_1]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_1]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_331] = [__v_0]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_0]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_11]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_11]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31323,15 +30939,15 @@ fn aiur_fn_331( }) } -const INPUT_SIZE_332: usize = 1; -const IN_332: usize = 1; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_330: usize = 1; +const IN_330: usize = 1; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -31343,48 +30959,48 @@ fn aiur_fn_332( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_6]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_6]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_7]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_6]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_6]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31394,15 +31010,15 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 2; -const IN_333: usize = 2; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_331: usize = 2; +const IN_331: usize = 2; +const OUT_331: usize = 1; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31415,47 +31031,47 @@ fn aiur_fn_333( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_7]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_8]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_7]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_7]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_5]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_5]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31465,15 +31081,15 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_332: usize = 2; +const IN_332: usize = 2; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31486,19 +31102,19 @@ fn aiur_fn_334( 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_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_7]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_8]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31508,15 +31124,15 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 2; -const IN_335: usize = 2; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_333: usize = 2; +const IN_333: usize = 2; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31526,30 +31142,30 @@ fn aiur_fn_335( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_335] = [__v_0]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_0]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_5]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_5]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_336: usize = 2; -const IN_336: usize = 2; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31563,94 +31179,94 @@ fn aiur_fn_336( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_9]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_9]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_9]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_10]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_10]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_10]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_10]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31660,15 +31276,15 @@ fn aiur_fn_336( }) } -const INPUT_SIZE_337: usize = 2; -const IN_337: usize = 2; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_335: usize = 2; +const IN_335: usize = 2; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31699,14 +31315,14 @@ fn aiur_fn_337( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_337] = [__v_22]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_22]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31726,25 +31342,25 @@ fn aiur_fn_337( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_22]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_23]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_23]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_23]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_23]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31764,15 +31380,15 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 2; -const IN_338: usize = 2; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_336: usize = 2; +const IN_336: usize = 2; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31789,14 +31405,14 @@ fn aiur_fn_338( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31809,24 +31425,24 @@ fn aiur_fn_338( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_9]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_9]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31843,15 +31459,15 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 4; -const IN_339: usize = 4; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_337: usize = 4; +const IN_337: usize = 4; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31861,16 +31477,16 @@ fn aiur_fn_339( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_4]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_4]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31878,16 +31494,16 @@ fn aiur_fn_339( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_4]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_4]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31899,15 +31515,15 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 1; -const IN_340: usize = 1; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_338: usize = 1; +const IN_338: usize = 1; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -31919,77 +31535,77 @@ fn aiur_fn_340( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_340] = [__v_6]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_6]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_5]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_5]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_5]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_7]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_7]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_8]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_8]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_8]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_8]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_5]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_5]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31999,59 +31615,59 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 3; -const IN_341: usize = 3; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_339: usize = 3; +const IN_339: usize = 3; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_8]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_342: usize = 2; -const IN_342: usize = 2; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_340: usize = 2; +const IN_340: usize = 2; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_342] = [__v_1]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_1]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_342] = [__v_0]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_0]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32061,57 +31677,57 @@ fn aiur_fn_342( }) } -const INPUT_SIZE_343: usize = 1; -const IN_343: usize = 1; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_341: usize = 1; +const IN_341: usize = 1; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_343] = [__v_1]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_1]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_343] = [__v_2]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_2]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_344: usize = 2; -const IN_344: usize = 2; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_342: usize = 2; +const IN_342: usize = 2; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_344] = [__v_0]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_0]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_344] = [__v_1]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_1]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32121,34 +31737,15 @@ fn aiur_fn_344( }) } -const INPUT_SIZE_345: usize = 2; -const IN_345: usize = 2; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_345] = [__v_2]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_346: usize = 3; -const IN_346: usize = 3; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_343: usize = 3; +const IN_343: usize = 3; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32164,14 +31761,14 @@ fn aiur_fn_346( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_8]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_346] = [__v_8]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32181,37 +31778,37 @@ fn aiur_fn_346( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_346] = [__v_8]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_8]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32220,31 +31817,31 @@ fn aiur_fn_346( } }, 4u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32254,27 +31851,27 @@ fn aiur_fn_346( }) } -const INPUT_SIZE_347: usize = 4; -const IN_347: usize = 4; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_344: usize = 4; +const IN_344: usize = 4; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_347] = [__v_5]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_5]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32282,10 +31879,10 @@ fn aiur_fn_347( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_9]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_9]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32295,38 +31892,38 @@ fn aiur_fn_347( }) } -const INPUT_SIZE_348: usize = 5; -const IN_348: usize = 5; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_345: usize = 5; +const IN_345: usize = 5; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_348] = [__v_6]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_6]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_348] = [__v_7]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_7]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32334,10 +31931,10 @@ fn aiur_fn_348( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_348] = [__v_11]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_11]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32352,60 +31949,60 @@ fn aiur_fn_348( }) } -const INPUT_SIZE_349: usize = 2; -const IN_349: usize = 2; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_346: usize = 2; +const IN_346: usize = 2; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_349] = [__v_4]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_4]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_350: usize = 2; -const IN_350: usize = 2; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_347: usize = 2; +const IN_347: usize = 2; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_350] = [__v_2]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_2]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_350] = [__v_7]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32415,15 +32012,15 @@ fn aiur_fn_350( }) } -const INPUT_SIZE_351: usize = 1; -const IN_351: usize = 1; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_348: usize = 1; +const IN_348: usize = 1; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_348], 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 }; @@ -32433,13 +32030,13 @@ fn aiur_fn_351( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_351] = [__v_7]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_7]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32449,44 +32046,44 @@ fn aiur_fn_351( }) } -const INPUT_SIZE_352: usize = 2; -const IN_352: usize = 2; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_349: usize = 2; +const IN_349: usize = 2; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_352] = [__v_2]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_2]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_352] = [__v_2]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_2]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_7]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32498,15 +32095,15 @@ fn aiur_fn_352( }) } -const INPUT_SIZE_353: usize = 2; -const IN_353: usize = 2; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32515,31 +32112,31 @@ fn aiur_fn_353( 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_353] = [__v_4]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_4]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_353] = [__v_0]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_0]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_7]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32551,51 +32148,51 @@ fn aiur_fn_353( }) } -const INPUT_SIZE_354: usize = 2; -const IN_354: usize = 2; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_351: usize = 2; +const IN_351: usize = 2; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_354] = [__v_6]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_6]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_6]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_6]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_355: usize = 2; -const IN_355: usize = 2; -const OUT_355: usize = 1; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_352: usize = 2; +const IN_352: usize = 2; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], ExecError> { +) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32606,19 +32203,19 @@ fn aiur_fn_355( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_7]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); - let __ret: [G; OUT_355] = [__v_7]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32628,59 +32225,59 @@ fn aiur_fn_355( }, 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_8]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_8]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32690,100 +32287,100 @@ fn aiur_fn_355( }) } -const INPUT_SIZE_356: usize = 3; -const IN_356: usize = 3; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_353: usize = 3; +const IN_353: usize = 3; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_7]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_357: usize = 4; -const IN_357: usize = 4; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_354: usize = 4; +const IN_354: usize = 4; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_357] = [__v_10]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_10]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_358: usize = 3; -const IN_358: usize = 3; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_355: usize = 3; +const IN_355: usize = 3; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_358] = [__v_0]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_0]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_358] = [__v_0]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_0]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_358] = [__v_5]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_5]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32795,15 +32392,15 @@ fn aiur_fn_358( }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 1; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_356: usize = 3; +const IN_356: usize = 3; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], ExecError> { +) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32815,90 +32412,90 @@ fn aiur_fn_359( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_7]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_11]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_11]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_13]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_13]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_13]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_13]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_7]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32908,15 +32505,15 @@ fn aiur_fn_359( }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 1; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_357: usize = 3; +const IN_357: usize = 3; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_360], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32927,8 +32524,8 @@ fn aiur_fn_360( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_6]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_6]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32936,8 +32533,8 @@ fn aiur_fn_360( let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_7]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_7]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32947,15 +32544,15 @@ fn aiur_fn_360( }) } -const INPUT_SIZE_361: usize = 5; -const IN_361: usize = 5; -const OUT_361: usize = 1; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_358: usize = 5; +const IN_358: usize = 5; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32963,56 +32560,56 @@ fn aiur_fn_361( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_11]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_11]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_362: usize = 3; -const IN_362: usize = 3; -const OUT_362: usize = 1; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_359: usize = 3; +const IN_359: usize = 3; +const OUT_359: usize = 1; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], ExecError> { +) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_362] = [__v_0]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_362] = [__v_0]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_5]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_5]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33024,15 +32621,15 @@ fn aiur_fn_362( }) } -const INPUT_SIZE_363: usize = 3; -const IN_363: usize = 3; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 1; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], ExecError> { +) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33047,8 +32644,8 @@ fn aiur_fn_363( let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_363] = [__v_0]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_0]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33056,8 +32653,8 @@ fn aiur_fn_363( let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_11]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_11]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33069,88 +32666,88 @@ fn aiur_fn_363( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_11]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_11]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33160,15 +32757,15 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 2; -const IN_364: usize = 2; -const OUT_364: usize = 1; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_361: usize = 2; +const IN_361: usize = 2; +const OUT_361: usize = 1; +fn aiur_fn_361( + inp: [G; IN_361], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], ExecError> { +) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33183,150 +32780,150 @@ fn aiur_fn_364( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_364] = [__v_7]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_364] = [__v_7]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_364] = [__v_7]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_7]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_365: usize = 3; -const IN_365: usize = 3; -const OUT_365: usize = 1; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_362: usize = 3; +const IN_362: usize = 3; +const OUT_362: usize = 1; +fn aiur_fn_362( + inp: [G; IN_362], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], ExecError> { +) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_365] = [__v_4]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_4]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_6]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 4; -const IN_366: usize = 4; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_363: usize = 4; +const IN_363: usize = 4; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: [G; IN_363], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], ExecError> { +) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_5]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_5]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_6]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 + __v_6); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_366] = [__v_8]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_8]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33335,48 +32932,48 @@ fn aiur_fn_366( }) } -const INPUT_SIZE_367: usize = 3; -const IN_367: usize = 3; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: [G; IN_364], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_367] = [__v_0]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_0]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_9]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33388,15 +32985,15 @@ fn aiur_fn_367( }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_365: usize = 3; +const IN_365: usize = 3; +const OUT_365: usize = 1; +fn aiur_fn_365( + inp: [G; IN_365], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], ExecError> { +) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33408,90 +33005,90 @@ fn aiur_fn_368( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_7]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_11]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_11]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_13]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_13]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_13]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_13]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_7]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33501,28 +33098,28 @@ fn aiur_fn_368( }) } -const INPUT_SIZE_369: usize = 3; -const IN_369: usize = 3; -const OUT_369: usize = 1; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_366: usize = 3; +const IN_366: usize = 3; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: [G; IN_366], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], ExecError> { +) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_6]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33530,10 +33127,10 @@ fn aiur_fn_369( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_6]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33542,8 +33139,8 @@ fn aiur_fn_369( let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_9]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33555,15 +33152,15 @@ fn aiur_fn_369( }) } -const INPUT_SIZE_370: usize = 5; -const IN_370: usize = 5; -const OUT_370: usize = 1; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_367: usize = 5; +const IN_367: usize = 5; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33571,71 +33168,71 @@ fn aiur_fn_370( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_11]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_367] = [__v_11]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_371: usize = 3; -const IN_371: usize = 3; -const OUT_371: usize = 1; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_368: usize = 3; +const IN_368: usize = 3; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_371] = [__v_0]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_0]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_371] = [__v_0]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_0]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_8]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_8]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_9]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33649,33 +33246,33 @@ fn aiur_fn_371( }) } -const INPUT_SIZE_372: usize = 3; -const IN_372: usize = 3; -const OUT_372: usize = 1; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], ExecError> { +) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_8]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_8]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33683,8 +33280,8 @@ fn aiur_fn_372( let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_372] = [__v_9]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33694,15 +33291,15 @@ fn aiur_fn_372( }) } -const INPUT_SIZE_373: usize = 3; -const IN_373: usize = 3; -const OUT_373: usize = 1; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_370: usize = 3; +const IN_370: usize = 3; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33714,90 +33311,90 @@ fn aiur_fn_373( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_7]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_7]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_11]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_11]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_13]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_13]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_13]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_13]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_7]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_7]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33807,15 +33404,15 @@ fn aiur_fn_373( }) } -const INPUT_SIZE_374: usize = 5; -const IN_374: usize = 5; -const OUT_374: usize = 1; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_371: usize = 5; +const IN_371: usize = 5; +const OUT_371: usize = 1; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33823,30 +33420,30 @@ fn aiur_fn_374( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_11]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_11]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_375: usize = 3; -const IN_375: usize = 3; -const OUT_375: usize = 3; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_372: usize = 3; +const IN_372: usize = 3; +const OUT_372: usize = 3; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33866,17 +33463,17 @@ fn aiur_fn_375( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_375] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33885,23 +33482,23 @@ fn aiur_fn_375( } }, _ => { - let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_376: usize = 3; -const IN_376: usize = 3; -const OUT_376: usize = 1; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_373: usize = 3; +const IN_373: usize = 3; +const OUT_373: usize = 1; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33909,56 +33506,56 @@ fn aiur_fn_376( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_10]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_10]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_14]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_14]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_12]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_12]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 3; -const IN_377: usize = 3; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_374: usize = 3; +const IN_374: usize = 3; +const OUT_374: usize = 1; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33970,90 +33567,90 @@ fn aiur_fn_377( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_10]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_10]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_9]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_378: usize = 5; -const IN_378: usize = 5; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_375: usize = 5; +const IN_375: usize = 5; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_11]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_11]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34064,7 +33661,7 @@ fn aiur_fn_378( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -34082,21 +33679,21 @@ fn aiur_fn_378( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_30]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_30]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_30]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_30]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34104,10 +33701,10 @@ fn aiur_fn_378( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_17]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_17]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34116,317 +33713,317 @@ fn aiur_fn_378( }) } -const INPUT_SIZE_379: usize = 0; -const IN_379: usize = 0; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_376: usize = 0; +const IN_376: usize = 0; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(167); - let __v_1: G = G::from_u64(233); - let __v_2: G = G::from_u64(168); - let __v_3: G = G::from_u64(184); - let __v_4: G = G::from_u64(74); - let __v_5: G = G::from_u64(47); - let __v_6: G = G::from_u64(233); - let __v_7: G = G::from_u64(108); - let __v_8: G = G::from_u64(194); - let __v_9: G = G::from_u64(4); - let __v_10: G = G::from_u64(172); - let __v_11: G = G::from_u64(201); - let __v_12: G = G::from_u64(61); + 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(209); - let __v_15: G = G::from_u64(54); - let __v_16: G = G::from_u64(109); - let __v_17: G = G::from_u64(157); - let __v_18: G = G::from_u64(5); - let __v_19: G = G::from_u64(116); - let __v_20: G = G::from_u64(170); - let __v_21: G = G::from_u64(240); - let __v_22: G = G::from_u64(240); - let __v_23: G = G::from_u64(150); - let __v_24: G = G::from_u64(51); - let __v_25: G = G::from_u64(210); - let __v_26: G = G::from_u64(176); - let __v_27: G = G::from_u64(154); - let __v_28: G = G::from_u64(148); - let __v_29: G = G::from_u64(201); - let __v_30: G = G::from_u64(232); - let __v_31: G = G::from_u64(96); + let __v_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_379] = [__v_32]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_32]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_380: usize = 0; -const IN_380: usize = 0; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_377: usize = 0; +const IN_377: usize = 0; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(106); - let __v_1: G = G::from_u64(247); - let __v_2: G = G::from_u64(56); - let __v_3: G = G::from_u64(9); - let __v_4: G = G::from_u64(166); - let __v_5: G = G::from_u64(18); - let __v_6: G = G::from_u64(138); - let __v_7: G = G::from_u64(220); - let __v_8: G = G::from_u64(185); - let __v_9: G = G::from_u64(197); - let __v_10: G = G::from_u64(215); - let __v_11: G = G::from_u64(231); - let __v_12: G = G::from_u64(58); - let __v_13: G = G::from_u64(48); - let __v_14: G = G::from_u64(194); - let __v_15: G = G::from_u64(141); - let __v_16: G = G::from_u64(72); - let __v_17: G = G::from_u64(157); - let __v_18: G = G::from_u64(186); - let __v_19: G = G::from_u64(77); - let __v_20: G = G::from_u64(144); - let __v_21: G = G::from_u64(87); - let __v_22: G = G::from_u64(23); - let __v_23: G = G::from_u64(5); - let __v_24: G = G::from_u64(90); - let __v_25: G = G::from_u64(194); - let __v_26: G = G::from_u64(237); - let __v_27: G = G::from_u64(215); - let __v_28: G = G::from_u64(85); - let __v_29: G = G::from_u64(255); - let __v_30: G = G::from_u64(167); - let __v_31: G = G::from_u64(19); + let __v_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_380] = [__v_32]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_32]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_381: usize = 0; -const IN_381: usize = 0; -const OUT_381: usize = 1; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_378: usize = 0; +const IN_378: usize = 0; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(29); - let __v_1: G = G::from_u64(255); - let __v_2: G = G::from_u64(253); - let __v_3: G = G::from_u64(228); - let __v_4: G = G::from_u64(140); - let __v_5: G = G::from_u64(78); - let __v_6: G = G::from_u64(246); - let __v_7: G = G::from_u64(101); - let __v_8: G = G::from_u64(59); - let __v_9: G = G::from_u64(149); - let __v_10: G = G::from_u64(236); - let __v_11: G = G::from_u64(197); - let __v_12: G = G::from_u64(71); - let __v_13: G = G::from_u64(77); - let __v_14: G = G::from_u64(238); - let __v_15: G = G::from_u64(139); - let __v_16: G = G::from_u64(153); - let __v_17: G = G::from_u64(70); - let __v_18: G = G::from_u64(16); - let __v_19: G = G::from_u64(8); - let __v_20: G = G::from_u64(210); - let __v_21: G = G::from_u64(109); - let __v_22: G = G::from_u64(128); - let __v_23: G = G::from_u64(202); - let __v_24: G = G::from_u64(56); - let __v_25: G = G::from_u64(79); - let __v_26: G = G::from_u64(30); - let __v_27: G = G::from_u64(89); - let __v_28: G = G::from_u64(233); - let __v_29: G = G::from_u64(39); - let __v_30: G = G::from_u64(113); - let __v_31: G = G::from_u64(77); + let __v_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_381] = [__v_32]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_32]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_382: usize = 0; -const IN_382: usize = 0; -const OUT_382: usize = 1; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_379: usize = 0; +const IN_379: usize = 0; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], ExecError> { +) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(10); - let __v_1: G = G::from_u64(76); - let __v_2: G = G::from_u64(199); - let __v_3: G = G::from_u64(201); - let __v_4: G = G::from_u64(48); - let __v_5: G = G::from_u64(221); - let __v_6: G = G::from_u64(103); - let __v_7: G = G::from_u64(38); - let __v_8: G = G::from_u64(187); - let __v_9: G = G::from_u64(215); - let __v_10: G = G::from_u64(241); - let __v_11: G = G::from_u64(188); - let __v_12: G = G::from_u64(63); - let __v_13: G = G::from_u64(234); - let __v_14: G = G::from_u64(104); - let __v_15: G = G::from_u64(93); - let __v_16: G = G::from_u64(245); - let __v_17: G = G::from_u64(246); - let __v_18: G = G::from_u64(102); - let __v_19: G = G::from_u64(84); - let __v_20: G = G::from_u64(157); - let __v_21: G = G::from_u64(101); - let __v_22: G = G::from_u64(29); - let __v_23: G = G::from_u64(62); - let __v_24: G = G::from_u64(118); - let __v_25: G = G::from_u64(111); - let __v_26: G = G::from_u64(229); - let __v_27: G = G::from_u64(116); - let __v_28: G = G::from_u64(110); - let __v_29: G = G::from_u64(196); - let __v_30: G = G::from_u64(89); - let __v_31: G = G::from_u64(164); + let __v_0: G = G::from_u64(136); + let __v_1: G = G::from_u64(38); + let __v_2: G = G::from_u64(102); + let __v_3: G = G::from_u64(119); + let __v_4: G = G::from_u64(254); + let __v_5: G = G::from_u64(231); + let __v_6: G = G::from_u64(116); + let __v_7: G = G::from_u64(209); + let __v_8: G = G::from_u64(9); + let __v_9: G = G::from_u64(134); + let __v_10: G = G::from_u64(126); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(34); + let __v_13: G = G::from_u64(64); + let __v_14: G = G::from_u64(40); + let __v_15: G = G::from_u64(26); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(18); + let __v_19: G = G::from_u64(217); + let __v_20: G = G::from_u64(121); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(193); + let __v_23: G = G::from_u64(23); + let __v_24: G = G::from_u64(28); + let __v_25: G = G::from_u64(245); + let __v_26: G = G::from_u64(193); + let __v_27: G = G::from_u64(246); + let __v_28: G = G::from_u64(200); + let __v_29: G = G::from_u64(125); + let __v_30: G = G::from_u64(236); + let __v_31: G = G::from_u64(246); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_32]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_32]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_383: usize = 0; -const IN_383: usize = 0; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_380: usize = 0; +const IN_380: usize = 0; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], ExecError> { +) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(86); - let __v_1: G = G::from_u64(2); - let __v_2: G = G::from_u64(118); - let __v_3: G = G::from_u64(249); - let __v_4: G = G::from_u64(94); - let __v_5: G = G::from_u64(13); - let __v_6: G = G::from_u64(147); - let __v_7: G = G::from_u64(226); - let __v_8: G = G::from_u64(123); - let __v_9: G = G::from_u64(140); - let __v_10: G = G::from_u64(5); - let __v_11: G = G::from_u64(9); - let __v_12: G = G::from_u64(121); - let __v_13: G = G::from_u64(149); - let __v_14: G = G::from_u64(191); - let __v_15: G = G::from_u64(130); - let __v_16: G = G::from_u64(135); - let __v_17: G = G::from_u64(99); - let __v_18: G = G::from_u64(50); - let __v_19: G = G::from_u64(194); - let __v_20: G = G::from_u64(231); - let __v_21: G = G::from_u64(227); - let __v_22: G = G::from_u64(16); - let __v_23: G = G::from_u64(51); - let __v_24: G = G::from_u64(224); - let __v_25: G = G::from_u64(161); - let __v_26: G = G::from_u64(148); - let __v_27: G = G::from_u64(129); - let __v_28: G = G::from_u64(158); - let __v_29: G = G::from_u64(78); - let __v_30: G = G::from_u64(141); - let __v_31: G = G::from_u64(48); + let __v_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_383] = [__v_32]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_380] = [__v_32]; + if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_384: usize = 0; -const IN_384: usize = 0; -const OUT_384: usize = 1; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_381: usize = 0; +const IN_381: usize = 0; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(2); - let __v_1: G = G::from_u64(243); - let __v_2: G = G::from_u64(88); - let __v_3: G = G::from_u64(128); - let __v_4: G = G::from_u64(143); - let __v_5: G = G::from_u64(212); - let __v_6: G = G::from_u64(50); - let __v_7: G = G::from_u64(141); - let __v_8: G = G::from_u64(116); - let __v_9: G = G::from_u64(133); - let __v_10: G = G::from_u64(5); - let __v_11: G = G::from_u64(130); - let __v_12: G = G::from_u64(211); - let __v_13: G = G::from_u64(96); - let __v_14: G = G::from_u64(141); - let __v_15: G = G::from_u64(45); - let __v_16: G = G::from_u64(49); - let __v_17: G = G::from_u64(228); - let __v_18: G = G::from_u64(149); - let __v_19: G = G::from_u64(25); - let __v_20: G = G::from_u64(180); - let __v_21: G = G::from_u64(198); - let __v_22: G = G::from_u64(198); - let __v_23: G = G::from_u64(107); - let __v_24: G = G::from_u64(54); - let __v_25: G = G::from_u64(5); - let __v_26: G = G::from_u64(251); - let __v_27: G = G::from_u64(230); - let __v_28: G = G::from_u64(244); - let __v_29: G = G::from_u64(45); - let __v_30: G = G::from_u64(60); - let __v_31: G = G::from_u64(93); + let __v_0: G = G::from_u64(18); + let __v_1: G = G::from_u64(73); + let __v_2: G = G::from_u64(132); + let __v_3: G = G::from_u64(188); + let __v_4: G = G::from_u64(185); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(8); + let __v_7: G = G::from_u64(160); + let __v_8: G = G::from_u64(243); + let __v_9: G = G::from_u64(11); + let __v_10: G = G::from_u64(182); + let __v_11: G = G::from_u64(157); + let __v_12: G = G::from_u64(103); + let __v_13: G = G::from_u64(54); + let __v_14: G = G::from_u64(211); + let __v_15: G = G::from_u64(213); + let __v_16: G = G::from_u64(148); + let __v_17: G = G::from_u64(4); + let __v_18: G = G::from_u64(225); + let __v_19: G = G::from_u64(21); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(32); + let __v_23: G = G::from_u64(67); + let __v_24: G = G::from_u64(253); + let __v_25: G = G::from_u64(163); + let __v_26: G = G::from_u64(211); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(176); + let __v_30: G = G::from_u64(173); + let __v_31: G = G::from_u64(22); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_32]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_381] = [__v_32]; + if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_385: usize = 4; -const IN_385: usize = 4; -const OUT_385: usize = 2; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_382: usize = 4; +const IN_382: usize = 4; +const OUT_382: usize = 2; +fn aiur_fn_382( + inp: [G; IN_382], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { +) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -34435,8 +34032,8 @@ fn aiur_fn_385( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34449,9 +34046,9 @@ fn aiur_fn_385( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -34460,12 +34057,12 @@ fn aiur_fn_385( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34476,25 +34073,25 @@ fn aiur_fn_385( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -34528,7 +34125,7 @@ fn aiur_fn_385( let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); @@ -34557,13 +34154,13 @@ fn aiur_fn_385( let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_77, __v_78]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_77, __v_78]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34572,8 +34169,8 @@ fn aiur_fn_385( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_42, __v_46]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_42, __v_46]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34584,8 +34181,8 @@ fn aiur_fn_385( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34596,8 +34193,8 @@ fn aiur_fn_385( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_29, __v_33]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_29, __v_33]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34612,8 +34209,8 @@ fn aiur_fn_385( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34624,8 +34221,8 @@ fn aiur_fn_385( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34634,15 +34231,15 @@ fn aiur_fn_385( }) } -const INPUT_SIZE_386: usize = 1; -const IN_386: usize = 1; -const OUT_386: usize = 1; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_383: usize = 1; +const IN_383: usize = 1; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_386], ExecError> { +) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -34652,10 +34249,10 @@ fn aiur_fn_386( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_5]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_5]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34670,23 +34267,23 @@ fn aiur_fn_386( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_15]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_15]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_387: usize = 2; -const IN_387: usize = 2; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_384: usize = 2; +const IN_384: usize = 2; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: [G; IN_384], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34699,19 +34296,19 @@ fn aiur_fn_387( 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_387] = [__v_7]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_7]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_387] = [__v_8]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_8]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34721,30 +34318,30 @@ fn aiur_fn_387( }) } -const INPUT_SIZE_388: usize = 3; -const IN_388: usize = 3; -const OUT_388: usize = 2; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_385: usize = 3; +const IN_385: usize = 3; +const OUT_385: usize = 2; +fn aiur_fn_385( + inp: [G; IN_385], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34757,31 +34354,31 @@ fn aiur_fn_388( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34790,8 +34387,8 @@ fn aiur_fn_388( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34810,33 +34407,33 @@ fn aiur_fn_388( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34845,8 +34442,8 @@ fn aiur_fn_388( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34854,11 +34451,11 @@ fn aiur_fn_388( } }, _ => { - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34867,19 +34464,19 @@ fn aiur_fn_388( }) } -const INPUT_SIZE_389: usize = 2; -const IN_389: usize = 2; -const OUT_389: usize = 1; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_386: usize = 2; +const IN_386: usize = 2; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: [G; IN_386], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __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]; @@ -34887,8 +34484,8 @@ fn aiur_fn_389( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_389] = [__v_2]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_2]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -34898,26 +34495,26 @@ fn aiur_fn_389( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_389] = [__v_2]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_2]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_17]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_17]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34932,20 +34529,20 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 1; -const IN_390: usize = 1; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_387: usize = 1; +const IN_387: usize = 1; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { @@ -34953,9 +34550,9 @@ fn aiur_fn_390( break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34963,9 +34560,9 @@ fn aiur_fn_390( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34973,9 +34570,9 @@ fn aiur_fn_390( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34983,9 +34580,9 @@ fn aiur_fn_390( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -34993,9 +34590,9 @@ fn aiur_fn_390( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -35003,9 +34600,9 @@ fn aiur_fn_390( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -35013,9 +34610,9 @@ fn aiur_fn_390( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -35023,9 +34620,9 @@ fn aiur_fn_390( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -35033,9 +34630,9 @@ fn aiur_fn_390( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { @@ -35043,9 +34640,9 @@ fn aiur_fn_390( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -35053,9 +34650,9 @@ fn aiur_fn_390( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { @@ -35063,9 +34660,9 @@ fn aiur_fn_390( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { @@ -35073,9 +34670,9 @@ fn aiur_fn_390( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -35083,9 +34680,9 @@ fn aiur_fn_390( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { @@ -35093,9 +34690,9 @@ fn aiur_fn_390( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { @@ -35142,64 +34739,64 @@ fn aiur_fn_390( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_390] = [__v_4]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_4]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_390] = [__v_5]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_5]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); - let __ret: [G; OUT_390] = [__v_6]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_6]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); - let __ret: [G; OUT_390] = [__v_7]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_7]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_390] = [__v_8]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_8]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); - let __ret: [G; OUT_390] = [__v_9]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_9]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_390] = [__v_9]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_9]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35216,71 +34813,71 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 4; -const IN_391: usize = 4; -const OUT_391: usize = 2; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_388: usize = 4; +const IN_388: usize = 4; +const OUT_388: usize = 2; +fn aiur_fn_388( + inp: [G; IN_388], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35289,52 +34886,52 @@ fn aiur_fn_391( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_391] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_392: usize = 3; -const IN_392: usize = 3; -const OUT_392: usize = 2; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_389: usize = 3; +const IN_389: usize = 3; +const OUT_389: usize = 2; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35343,8 +34940,8 @@ fn aiur_fn_392( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35353,19 +34950,19 @@ fn aiur_fn_392( }) } -const INPUT_SIZE_393: usize = 2; -const IN_393: usize = 2; -const OUT_393: usize = 2; -fn aiur_fn_393( - inp: [G; IN_393], +const INPUT_SIZE_390: usize = 2; +const IN_390: usize = 2; +const OUT_390: usize = 2; +fn aiur_fn_390( + inp: [G; IN_390], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_393], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35376,33 +34973,33 @@ fn aiur_fn_393( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_393] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35411,8 +35008,8 @@ fn aiur_fn_393( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_393] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35421,19 +35018,19 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; -const OUT_394: usize = 2; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_391: usize = 2; +const IN_391: usize = 2; +const OUT_391: usize = 2; +fn aiur_fn_391( + inp: [G; IN_391], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], ExecError> { +) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35444,33 +35041,33 @@ fn aiur_fn_394( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35479,8 +35076,8 @@ fn aiur_fn_394( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35489,21 +35086,21 @@ fn aiur_fn_394( }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 2; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_392: usize = 2; +const IN_392: usize = 2; +const OUT_392: usize = 2; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35513,13 +35110,13 @@ fn aiur_fn_395( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -35527,10 +35124,10 @@ fn aiur_fn_395( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_14, __v_16]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_14, __v_16]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35539,8 +35136,8 @@ fn aiur_fn_395( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35551,8 +35148,8 @@ fn aiur_fn_395( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35563,47 +35160,47 @@ fn aiur_fn_395( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_396: usize = 5; -const IN_396: usize = 5; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_393: usize = 5; +const IN_393: usize = 5; +const OUT_393: usize = 1; +fn aiur_fn_393( + inp: [G; IN_393], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], ExecError> { +) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_7]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_7]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_396] = [__v_6]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_6]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -35620,52 +35217,52 @@ fn aiur_fn_396( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_23]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_23]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_20]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_20]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35676,10 +35273,10 @@ fn aiur_fn_396( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -35694,46 +35291,46 @@ fn aiur_fn_396( let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_24]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_24]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_28]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_28]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_27]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_27]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_30]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_30]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_396] = [__v_27]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_27]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35741,10 +35338,10 @@ fn aiur_fn_396( } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_28]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_28]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35752,10 +35349,10 @@ fn aiur_fn_396( } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_20]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_20]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35764,20 +35361,20 @@ fn aiur_fn_396( }) } -const INPUT_SIZE_397: usize = 2; -const IN_397: usize = 2; -const OUT_397: usize = 2; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_394: usize = 2; +const IN_394: usize = 2; +const OUT_394: usize = 2; +fn aiur_fn_394( + inp: [G; IN_394], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -35785,7 +35382,7 @@ fn aiur_fn_397( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -35795,22 +35392,22 @@ fn aiur_fn_397( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35821,23 +35418,23 @@ fn aiur_fn_397( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_398: usize = 2; -const IN_398: usize = 2; -const OUT_398: usize = 5; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 5; +fn aiur_fn_395( + inp: [G; IN_395], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], ExecError> { +) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35850,14 +35447,14 @@ fn aiur_fn_398( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; - let __ret: [G; OUT_398] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -35875,8 +35472,8 @@ fn aiur_fn_398( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __v_14: G = (__v_13 - __v_7); - let __ret: [G; OUT_398] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35917,8 +35514,8 @@ fn aiur_fn_398( let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35961,8 +35558,8 @@ fn aiur_fn_398( let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36005,23 +35602,23 @@ fn aiur_fn_398( let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_399: usize = 1; -const IN_399: usize = 1; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_396: usize = 1; +const IN_396: usize = 1; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], ExecError> { +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36033,33 +35630,33 @@ fn aiur_fn_399( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_399] = [__v_12]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_12]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); @@ -36069,37 +35666,37 @@ fn aiur_fn_399( let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_399] = [__v_21]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_21]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_0]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_0]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 9; -const IN_400: usize = 9; -const OUT_400: usize = 2; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_397: usize = 9; +const IN_397: usize = 9; +const OUT_397: usize = 2; +fn aiur_fn_397( + inp: [G; IN_397], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], ExecError> { +) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36123,9 +35720,9 @@ fn aiur_fn_400( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -36134,14 +35731,14 @@ fn aiur_fn_400( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -36150,30 +35747,30 @@ fn aiur_fn_400( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_21, __v_25]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_21, __v_25]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_30, __v_31]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_30, __v_31]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36188,34 +35785,34 @@ fn aiur_fn_400( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_401: usize = 5; -const IN_401: usize = 5; -const OUT_401: usize = 1; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_398: usize = 5; +const IN_398: usize = 5; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], ExecError> { +) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36225,17 +35822,17 @@ fn aiur_fn_401( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_14]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_14]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -36252,27 +35849,27 @@ fn aiur_fn_401( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { 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_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_34]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_34]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_27]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_27]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36281,63 +35878,63 @@ fn aiur_fn_401( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_13]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_13]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_402: usize = 3; -const IN_402: usize = 3; -const OUT_402: usize = 1; -fn aiur_fn_402( - inp: [G; IN_402], +const INPUT_SIZE_399: usize = 3; +const IN_399: usize = 3; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], ExecError> { +) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_13]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_13]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_403: usize = 2; -const IN_403: usize = 2; -const OUT_403: usize = 1; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_400: usize = 2; +const IN_400: usize = 2; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], ExecError> { +) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36347,7 +35944,7 @@ fn aiur_fn_403( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -36364,41 +35961,41 @@ fn aiur_fn_403( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_24]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_24]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_403] = [__v_2]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_2]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_403] = [__v_2]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_2]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_404: usize = 10; -const IN_404: usize = 10; -const OUT_404: usize = 2; -fn aiur_fn_404( - inp: [G; IN_404], +const INPUT_SIZE_401: usize = 10; +const IN_401: usize = 10; +const OUT_401: usize = 2; +fn aiur_fn_401( + inp: [G; IN_401], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_404], ExecError> { +) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36413,7 +36010,7 @@ fn aiur_fn_404( let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -36423,44 +36020,44 @@ fn aiur_fn_404( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_404] = [__v_17, __v_16]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_17, __v_16]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { @@ -36468,40 +36065,40 @@ fn aiur_fn_404( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_32, __v_33]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_32, __v_33]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_404] = [__v_44, __v_43]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_44, __v_43]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36510,13 +36107,13 @@ fn aiur_fn_404( } }, _ => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36527,18 +36124,18 @@ fn aiur_fn_404( }) } -const INPUT_SIZE_405: usize = 1; -const IN_405: usize = 1; -const OUT_405: usize = 4; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_402: usize = 1; +const IN_402: usize = 1; +const OUT_402: usize = 4; +fn aiur_fn_402( + inp: [G; IN_402], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36548,7 +36145,7 @@ fn aiur_fn_405( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -36566,10 +36163,10 @@ fn aiur_fn_405( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_20, __v_13, __v_21, __v_2]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_20, __v_13, __v_21, __v_2]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36611,8 +36208,8 @@ fn aiur_fn_405( let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_20, __v_21, __v_54, __v_57]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_20, __v_21, __v_54, __v_57]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36656,23 +36253,23 @@ fn aiur_fn_405( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_7, __v_8, __v_41, __v_44]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_7, __v_8, __v_41, __v_44]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_406: usize = 2; -const IN_406: usize = 2; -const OUT_406: usize = 3; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_403: usize = 2; +const IN_403: usize = 2; +const OUT_403: usize = 3; +fn aiur_fn_403( + inp: [G; IN_403], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36690,8 +36287,8 @@ fn aiur_fn_406( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_7, __v_8, __v_12]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_7, __v_8, __v_12]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36701,17 +36298,17 @@ fn aiur_fn_406( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_406] = [__v_8, __v_4, __v_5]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_8, __v_4, __v_5]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_406] = [__v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36725,15 +36322,15 @@ fn aiur_fn_406( }) } -const INPUT_SIZE_407: usize = 9; -const IN_407: usize = 9; -const OUT_407: usize = 2; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_404: usize = 9; +const IN_404: usize = 9; +const OUT_404: usize = 2; +fn aiur_fn_404( + inp: [G; IN_404], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36757,8 +36354,8 @@ fn aiur_fn_407( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36775,8 +36372,8 @@ fn aiur_fn_407( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -36785,7 +36382,7 @@ fn aiur_fn_407( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -36795,12 +36392,12 @@ fn aiur_fn_407( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_24, __v_28]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_24, __v_28]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -36823,7 +36420,7 @@ fn aiur_fn_407( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -36832,18 +36429,18 @@ fn aiur_fn_407( 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_407] = [__v_40, __v_44]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_40, __v_44]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { @@ -36852,14 +36449,14 @@ fn aiur_fn_407( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_44, __v_48]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_44, __v_48]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -36868,31 +36465,31 @@ fn aiur_fn_407( let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_46, __v_50]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_46, __v_50]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_56, __v_57]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_56, __v_57]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36907,8 +36504,8 @@ fn aiur_fn_407( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36919,8 +36516,8 @@ fn aiur_fn_407( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36931,8 +36528,8 @@ fn aiur_fn_407( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_37, __v_41]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_37, __v_41]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36953,15 +36550,15 @@ fn aiur_fn_407( }) } -const INPUT_SIZE_408: usize = 2; -const IN_408: usize = 2; -const OUT_408: usize = 2; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_405: usize = 2; +const IN_405: usize = 2; +const OUT_405: usize = 2; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36974,7 +36571,7 @@ fn aiur_fn_408( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36985,8 +36582,8 @@ fn aiur_fn_408( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_408] = [__v_12, __v_9]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_12, __v_9]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37024,8 +36621,8 @@ fn aiur_fn_408( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_12, __v_45]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_12, __v_45]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37065,8 +36662,8 @@ fn aiur_fn_408( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37081,11 +36678,11 @@ fn aiur_fn_408( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_408] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37123,8 +36720,8 @@ fn aiur_fn_408( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37133,15 +36730,15 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 5; -const IN_409: usize = 5; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_406: usize = 5; +const IN_406: usize = 5; +const OUT_406: usize = 1; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37151,8 +36748,8 @@ fn aiur_fn_409( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_409] = [__v_0]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_0]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37163,28 +36760,28 @@ fn aiur_fn_409( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_13]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_13]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 1; -const IN_410: usize = 1; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_407: usize = 1; +const IN_407: usize = 1; +const OUT_407: usize = 1; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -37201,38 +36798,38 @@ fn aiur_fn_410( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_16]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_16]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_410] = [__v_14]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_14]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 2; -const IN_411: usize = 2; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_408: usize = 2; +const IN_408: usize = 2; +const OUT_408: usize = 1; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], ExecError> { +) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -37285,10 +36882,10 @@ fn aiur_fn_411( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_50]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_50]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37297,8 +36894,8 @@ fn aiur_fn_411( let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_411] = [__v_54]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_54]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37307,15 +36904,15 @@ fn aiur_fn_411( }) } -const INPUT_SIZE_412: usize = 6; -const IN_412: usize = 6; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_409: usize = 6; +const IN_409: usize = 6; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], ExecError> { +) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37327,12 +36924,12 @@ fn aiur_fn_412( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_7]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -37349,32 +36946,32 @@ fn aiur_fn_412( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_22]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_22]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_24]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_24]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_20]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_20]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37383,22 +36980,22 @@ fn aiur_fn_412( }) } -const INPUT_SIZE_413: usize = 2; -const IN_413: usize = 2; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_410: usize = 2; +const IN_410: usize = 2; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], ExecError> { +) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_413] = [__v_0]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_0]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37411,15 +37008,15 @@ fn aiur_fn_413( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_8]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_8]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_413] = [__v_0]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_0]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37428,15 +37025,15 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 2; -const IN_414: usize = 2; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_411: usize = 2; +const IN_411: usize = 2; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37447,43 +37044,43 @@ fn aiur_fn_414( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_7]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_7]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_7]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_7]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_6]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_6]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_415: usize = 2; -const IN_415: usize = 2; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_412: usize = 2; +const IN_412: usize = 2; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], ExecError> { +) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37494,94 +37091,94 @@ fn aiur_fn_415( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_6]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_8]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_8]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_8]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_8]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37589,31 +37186,31 @@ fn aiur_fn_415( } }, 8u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_6]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_6]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 2; -const IN_416: usize = 2; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_413: usize = 2; +const IN_413: usize = 2; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], ExecError> { +) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37624,25 +37221,25 @@ fn aiur_fn_416( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_416] = [__v_5]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_5]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_6]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_6]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_6]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_6]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37654,15 +37251,15 @@ fn aiur_fn_416( }) } -const INPUT_SIZE_417: usize = 2; -const IN_417: usize = 2; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_414: usize = 2; +const IN_414: usize = 2; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37673,80 +37270,80 @@ fn aiur_fn_417( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_417] = [__v_0]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_417] = [__v_0]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_417] = [__v_0]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_417] = [__v_0]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_417] = [__v_0]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_11]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_11]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 2; -const IN_418: usize = 2; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_415: usize = 2; +const IN_415: usize = 2; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], ExecError> { +) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_377] = { let __args: [G; IN_377] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_5]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_5]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_419: usize = 2; -const IN_419: usize = 2; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_416: usize = 2; +const IN_416: usize = 2; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37757,57 +37354,57 @@ fn aiur_fn_419( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_419] = [__v_0]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_419] = [__v_0]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_419] = [__v_0]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_419] = [__v_0]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_419] = [__v_0]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_11]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_11]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_420: usize = 3; -const IN_420: usize = 3; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_417: usize = 3; +const IN_417: usize = 3; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], ExecError> { +) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37819,104 +37416,104 @@ fn aiur_fn_420( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_10]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_10]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_14]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_14]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_18]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_18]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_16]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_16]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_9]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_9]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 6; -const IN_421: usize = 6; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_418: usize = 6; +const IN_418: usize = 6; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], ExecError> { +) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37924,9 +37521,9 @@ fn aiur_fn_421( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -37936,7 +37533,7 @@ fn aiur_fn_421( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -37954,50 +37551,50 @@ fn aiur_fn_421( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_28]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_28]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_26]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_26]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_13]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_13]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 5; -const IN_422: usize = 5; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_419: usize = 5; +const IN_419: usize = 5; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -38014,48 +37611,48 @@ fn aiur_fn_422( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_21]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_21]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_21]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_21]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_18]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_18]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 2; -const IN_423: usize = 2; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_420: usize = 2; +const IN_420: usize = 2; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38066,80 +37663,80 @@ fn aiur_fn_423( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_423] = [__v_0]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_423] = [__v_0]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_423] = [__v_0]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_423] = [__v_0]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_423] = [__v_0]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_11]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_11]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 2; -const IN_424: usize = 2; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_421: usize = 2; +const IN_421: usize = 2; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], ExecError> { +) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_425] = { let __args: [G; IN_425] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_5]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_5]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_425: usize = 3; -const IN_425: usize = 3; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_422: usize = 3; +const IN_422: usize = 3; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], ExecError> { +) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38151,68 +37748,68 @@ fn aiur_fn_425( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_10]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_10]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_9]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_9]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_426: usize = 3; -const IN_426: usize = 3; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_423: usize = 3; +const IN_423: usize = 3; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], ExecError> { +) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38220,78 +37817,78 @@ fn aiur_fn_426( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_10]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_10]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_14]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_14]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_12]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_12]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_427: usize = 5; -const IN_427: usize = 5; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_424: usize = 5; +const IN_424: usize = 5; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], ExecError> { +) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_11]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_11]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38302,7 +37899,7 @@ fn aiur_fn_427( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -38320,21 +37917,21 @@ fn aiur_fn_427( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_30]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_30]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_30]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_30]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38342,10 +37939,10 @@ fn aiur_fn_427( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_17]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_17]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38354,32 +37951,32 @@ fn aiur_fn_427( }) } -const INPUT_SIZE_428: usize = 5; -const IN_428: usize = 5; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_425: usize = 5; +const IN_425: usize = 5; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], ExecError> { +) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -38395,7 +37992,7 @@ fn aiur_fn_428( } }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -38406,19 +38003,19 @@ fn aiur_fn_428( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_8]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_8]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_428] = [__v_7]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38435,43 +38032,43 @@ fn aiur_fn_428( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38482,10 +38079,10 @@ fn aiur_fn_428( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -38500,46 +38097,46 @@ fn aiur_fn_428( let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_428] = [__v_25]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_25]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_29]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_29]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_428] = [__v_28]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_28]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_31]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_31]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_428] = [__v_28]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_28]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38547,10 +38144,10 @@ fn aiur_fn_428( } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_29]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_29]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38558,10 +38155,10 @@ fn aiur_fn_428( } }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_21]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_21]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38570,40 +38167,40 @@ fn aiur_fn_428( }) } -const INPUT_SIZE_429: usize = 2; -const IN_429: usize = 2; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_426: usize = 2; +const IN_426: usize = 2; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], ExecError> { +) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_6]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_6]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_430: usize = 12; -const IN_430: usize = 12; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_427: usize = 12; +const IN_427: usize = 12; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], ExecError> { +) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38619,43 +38216,43 @@ fn aiur_fn_430( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_430] = [__v_1]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38665,15 +38262,15 @@ fn aiur_fn_430( }) } -const INPUT_SIZE_431: usize = 12; -const IN_431: usize = 12; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_428: usize = 12; +const IN_428: usize = 12; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], ExecError> { +) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38689,43 +38286,43 @@ fn aiur_fn_431( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_431] = [__v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38735,21 +38332,21 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 2; -const IN_432: usize = 2; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_429: usize = 2; +const IN_429: usize = 2; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], ExecError> { +) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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_4: G = __loaded[0]; @@ -38758,15 +38355,15 @@ fn aiur_fn_432( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_12]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_12]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -38774,16 +38371,16 @@ fn aiur_fn_432( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38798,23 +38395,23 @@ fn aiur_fn_432( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_24]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_24]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38824,14 +38421,14 @@ fn aiur_fn_432( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -38841,10 +38438,10 @@ fn aiur_fn_432( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_19]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_19]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38857,67 +38454,67 @@ fn aiur_fn_432( 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_13]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_13]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_15]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_15]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_10]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_10]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38926,11 +38523,11 @@ fn aiur_fn_432( } }, 8u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38940,7 +38537,7 @@ fn aiur_fn_432( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38961,7 +38558,7 @@ fn aiur_fn_432( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -38982,15 +38579,15 @@ fn aiur_fn_432( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_47]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_47]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39015,15 +38612,15 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 2; -const IN_433: usize = 2; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_430: usize = 2; +const IN_430: usize = 2; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], ExecError> { +) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39034,15 +38631,15 @@ fn aiur_fn_433( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_10]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_10]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -39050,16 +38647,16 @@ fn aiur_fn_433( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -39074,23 +38671,23 @@ fn aiur_fn_433( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_22]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_22]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -39100,14 +38697,14 @@ fn aiur_fn_433( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_12]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39117,10 +38714,10 @@ fn aiur_fn_433( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_17]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_17]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39133,67 +38730,67 @@ fn aiur_fn_433( 4u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_11]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_11]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_13]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_13]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_8]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_8]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39202,11 +38799,11 @@ fn aiur_fn_433( } }, 8u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39216,7 +38813,7 @@ fn aiur_fn_433( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -39237,7 +38834,7 @@ fn aiur_fn_433( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; @@ -39258,15 +38855,15 @@ fn aiur_fn_433( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_45]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_45]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39291,19 +38888,19 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 2; -const IN_434: usize = 2; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_431: usize = 2; +const IN_431: usize = 2; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], ExecError> { +) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -39312,12 +38909,12 @@ fn aiur_fn_434( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_434] = [__v_4]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_4]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __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]; @@ -39326,8 +38923,8 @@ fn aiur_fn_434( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_9]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39339,23 +38936,23 @@ fn aiur_fn_434( }) } -const INPUT_SIZE_435: usize = 3; -const IN_435: usize = 3; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_432: usize = 3; +const IN_432: usize = 3; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], ExecError> { +) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_435] = [__v_0]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_0]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39373,14 +38970,14 @@ fn aiur_fn_435( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_14]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39397,15 +38994,15 @@ fn aiur_fn_435( }) } -const INPUT_SIZE_436: usize = 5; -const IN_436: usize = 5; -const OUT_436: usize = 1; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_433: usize = 5; +const IN_433: usize = 5; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39422,22 +39019,22 @@ fn aiur_fn_436( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_436] = [__v_6]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_6]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_16]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_16]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39449,15 +39046,15 @@ fn aiur_fn_436( }) } -const INPUT_SIZE_437: usize = 2; -const IN_437: usize = 2; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_437], +const INPUT_SIZE_434: usize = 2; +const IN_434: usize = 2; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], ExecError> { +) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39474,14 +39071,14 @@ fn aiur_fn_437( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_437] = [__v_8]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_8]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39494,25 +39091,25 @@ fn aiur_fn_437( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_8]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_9]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_9]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_9]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_9]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39529,15 +39126,15 @@ fn aiur_fn_437( }) } -const INPUT_SIZE_438: usize = 3; -const IN_438: usize = 3; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_435: usize = 3; +const IN_435: usize = 3; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: [G; IN_435], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_438], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39546,33 +39143,33 @@ fn aiur_fn_438( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_438] = [__v_4]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_4]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { 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_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_10]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_10]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_7]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_7]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39581,73 +39178,73 @@ fn aiur_fn_438( }) } -const INPUT_SIZE_439: usize = 4; -const IN_439: usize = 4; -const OUT_439: usize = 1; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_436: usize = 4; +const IN_436: usize = 4; +const OUT_436: usize = 1; +fn aiur_fn_436( + inp: [G; IN_436], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_12]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_12]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_18]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_18]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 3; -const IN_440: usize = 3; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_437: usize = 3; +const IN_437: usize = 3; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: [G; IN_437], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39655,73 +39252,73 @@ fn aiur_fn_440( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_4]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_4]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_4]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_4]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_441: usize = 3; -const IN_441: usize = 3; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_438: usize = 3; +const IN_438: usize = 3; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: [G; IN_438], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_441] = [__v_4]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_4]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_4]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_4]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_442: usize = 3; -const IN_442: usize = 3; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_439: usize = 3; +const IN_439: usize = 3; +const OUT_439: usize = 1; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39741,33 +39338,33 @@ fn aiur_fn_442( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_17]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_17]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_20]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_20]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_20]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_20]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39776,39 +39373,39 @@ fn aiur_fn_442( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_16]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_16]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_15]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_15]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_11]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_11]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_440: usize = 3; +const IN_440: usize = 3; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: [G; IN_440], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], ExecError> { +) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39826,14 +39423,14 @@ fn aiur_fn_443( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_443] = [__v_9]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_9]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39846,25 +39443,25 @@ fn aiur_fn_443( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_9]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_10]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_10]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_10]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_10]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39881,15 +39478,15 @@ fn aiur_fn_443( }) } -const INPUT_SIZE_444: usize = 1; -const IN_444: usize = 1; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_441: usize = 1; +const IN_441: usize = 1; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], ExecError> { +) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39901,48 +39498,48 @@ fn aiur_fn_444( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_5]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_5]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_6]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_6]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_5]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_445: usize = 1; -const IN_445: usize = 1; -const OUT_445: usize = 3; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_442: usize = 1; +const IN_442: usize = 1; +const OUT_442: usize = 3; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], ExecError> { +) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39958,10 +39555,10 @@ fn aiur_fn_445( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_5, __v_9, __v_3]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_9, __v_3]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39969,8 +39566,8 @@ fn aiur_fn_445( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39983,21 +39580,21 @@ fn aiur_fn_445( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_14, __v_12, __v_15]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -40005,8 +39602,8 @@ fn aiur_fn_445( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40019,9 +39616,9 @@ fn aiur_fn_445( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -40034,23 +39631,23 @@ fn aiur_fn_445( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_22, __v_20, __v_23]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_445] = [__v_22, __v_7, __v_17]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_22, __v_7, __v_17]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40060,8 +39657,8 @@ fn aiur_fn_445( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40071,8 +39668,8 @@ fn aiur_fn_445( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40082,8 +39679,8 @@ fn aiur_fn_445( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_15, __v_0, __v_18]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_15, __v_0, __v_18]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40093,8 +39690,8 @@ fn aiur_fn_445( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_13, __v_0, __v_16]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_13, __v_0, __v_16]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40104,8 +39701,8 @@ fn aiur_fn_445( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_9, __v_0, __v_12]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_9, __v_0, __v_12]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40115,46 +39712,46 @@ fn aiur_fn_445( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_446: usize = 3; -const IN_446: usize = 3; -const OUT_446: usize = 2; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_443: usize = 3; +const IN_443: usize = 3; +const OUT_443: usize = 2; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], ExecError> { +) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_446] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -40163,27 +39760,27 @@ fn aiur_fn_446( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_446] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_446] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40194,48 +39791,48 @@ fn aiur_fn_446( }) } -const INPUT_SIZE_447: usize = 3; -const IN_447: usize = 3; -const OUT_447: usize = 1; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_444: usize = 3; +const IN_444: usize = 3; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], ExecError> { +) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_4]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_4]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_447] = [__v_4]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_4]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_448: usize = 3; -const IN_448: usize = 3; -const OUT_448: usize = 1; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_445: usize = 3; +const IN_445: usize = 3; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: [G; IN_445], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], ExecError> { +) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40249,48 +39846,48 @@ fn aiur_fn_448( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_448] = [__v_9]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_9]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_448] = [__v_7]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_7]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_448] = [__v_7]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_7]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_449: usize = 3; -const IN_449: usize = 3; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 1; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -40298,7 +39895,7 @@ fn aiur_fn_449( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -40308,71 +39905,71 @@ fn aiur_fn_449( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_449] = [__v_5]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_5]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 3; -const IN_450: usize = 3; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 1; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_6]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_6]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_7]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_7]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_8]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_8]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_450] = [__v_8]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_8]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40383,58 +39980,58 @@ fn aiur_fn_450( }) } -const INPUT_SIZE_451: usize = 5; -const IN_451: usize = 5; -const OUT_451: usize = 1; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_448: usize = 5; +const IN_448: usize = 5; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_8]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_8]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_9]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_9]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_10]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_10]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_451] = [__v_10]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_10]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40445,15 +40042,15 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 3; -const IN_452: usize = 3; -const OUT_452: usize = 1; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_449: usize = 3; +const IN_449: usize = 3; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40472,16 +40069,16 @@ fn aiur_fn_452( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40494,30 +40091,30 @@ fn aiur_fn_452( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_14]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_14]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_12]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_12]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40530,53 +40127,53 @@ fn aiur_fn_452( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_14]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_14]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_12]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_12]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_7]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_7]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_453: usize = 5; -const IN_453: usize = 5; -const OUT_453: usize = 1; -fn aiur_fn_453( - inp: [G; IN_453], +const INPUT_SIZE_450: usize = 5; +const IN_450: usize = 5; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_453], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40587,78 +40184,78 @@ fn aiur_fn_453( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_6]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_6]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_7]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_8]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_8]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_9]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_9]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_10]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_10]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_453] = [__v_11]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_11]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_16]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_16]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_16]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_16]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40677,15 +40274,15 @@ fn aiur_fn_453( }) } -const INPUT_SIZE_454: usize = 5; -const IN_454: usize = 5; -const OUT_454: usize = 1; -fn aiur_fn_454( - inp: [G; IN_454], +const INPUT_SIZE_451: usize = 5; +const IN_451: usize = 5; +const OUT_451: usize = 1; +fn aiur_fn_451( + inp: [G; IN_451], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_454], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40693,31 +40290,31 @@ fn aiur_fn_454( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_8]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_8]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_9]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_9]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_454] = [__v_9]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_9]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40726,38 +40323,38 @@ fn aiur_fn_454( }) } -const INPUT_SIZE_455: usize = 3; -const IN_455: usize = 3; -const OUT_455: usize = 1; -fn aiur_fn_455( - inp: [G; IN_455], +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_455], ExecError> { +) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_8]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_8]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { @@ -40776,7 +40373,7 @@ fn aiur_fn_455( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_13 - __v_17); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); @@ -40786,40 +40383,40 @@ fn aiur_fn_455( let __v_25: G = (__v_19 * __v_24); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_26]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_26]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_26]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_26]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_19]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_19]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_15]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_11]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40828,45 +40425,45 @@ fn aiur_fn_455( }) } -const INPUT_SIZE_456: usize = 3; -const IN_456: usize = 3; -const OUT_456: usize = 1; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_453: usize = 3; +const IN_453: usize = 3; +const OUT_453: usize = 1; +fn aiur_fn_453( + inp: [G; IN_453], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { +) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(8); - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_6]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_6]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_7]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_456] = [__v_7]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40875,15 +40472,15 @@ fn aiur_fn_456( }) } -const INPUT_SIZE_457: usize = 3; -const IN_457: usize = 3; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_454: usize = 3; +const IN_454: usize = 3; +const OUT_454: usize = 1; +fn aiur_fn_454( + inp: [G; IN_454], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40902,51 +40499,51 @@ fn aiur_fn_457( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_12]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_12]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_12]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_12]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_11]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_11]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_7]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_458: usize = 4; -const IN_458: usize = 4; -const OUT_458: usize = 2; -fn aiur_fn_458( - inp: [G; IN_458], +const INPUT_SIZE_455: usize = 4; +const IN_455: usize = 4; +const OUT_455: usize = 2; +fn aiur_fn_455( + inp: [G; IN_455], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_458], ExecError> { +) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40956,8 +40553,8 @@ fn aiur_fn_458( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_458] = [__v_5, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_5, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -40979,24 +40576,24 @@ fn aiur_fn_458( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_458] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41009,18 +40606,18 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41033,32 +40630,32 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41071,32 +40668,32 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41109,34 +40706,34 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41149,34 +40746,34 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41189,18 +40786,18 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41213,54 +40810,54 @@ fn aiur_fn_458( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_2]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41269,15 +40866,15 @@ fn aiur_fn_458( }) } -const INPUT_SIZE_459: usize = 4; -const IN_459: usize = 4; -const OUT_459: usize = 2; -fn aiur_fn_459( - inp: [G; IN_459], +const INPUT_SIZE_456: usize = 4; +const IN_456: usize = 4; +const OUT_456: usize = 2; +fn aiur_fn_456( + inp: [G; IN_456], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_459], ExecError> { +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41287,54 +40884,54 @@ fn aiur_fn_459( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_9, __v_5]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_9, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_459] = [__v_10, __v_5]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_10, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_15, __v_5]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_15, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41347,96 +40944,96 @@ fn aiur_fn_459( }) } -const INPUT_SIZE_460: usize = 3; -const IN_460: usize = 3; -const OUT_460: usize = 1; -fn aiur_fn_460( - inp: [G; IN_460], +const INPUT_SIZE_457: usize = 3; +const IN_457: usize = 3; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_460], ExecError> { +) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_6]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_6]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_7]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_7]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_8]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_8]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_9]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_9]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_10]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_10]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_460] = [__v_11]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_11]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_13]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_13]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_460] = [__v_13]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_13]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41455,20 +41052,20 @@ fn aiur_fn_460( }) } -const INPUT_SIZE_461: usize = 3; -const IN_461: usize = 3; -const OUT_461: usize = 1; -fn aiur_fn_461( - inp: [G; IN_461], +const INPUT_SIZE_458: usize = 3; +const IN_458: usize = 3; +const OUT_458: usize = 1; +fn aiur_fn_458( + inp: [G; IN_458], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_461], ExecError> { +) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41478,7 +41075,7 @@ fn aiur_fn_461( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -41495,13 +41092,13 @@ fn aiur_fn_461( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -41526,42 +41123,42 @@ fn aiur_fn_461( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_43]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_43]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_45]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_45]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_48]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_48]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_49]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_49]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41572,47 +41169,47 @@ fn aiur_fn_461( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_38]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_38]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_25]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_25]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_22]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_22]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_9]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_9]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_462: usize = 7; -const IN_462: usize = 7; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_459: usize = 7; +const IN_459: usize = 7; +const OUT_459: usize = 1; +fn aiur_fn_459( + inp: [G; IN_459], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41625,32 +41222,32 @@ fn aiur_fn_462( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_462] = [__v_8]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_8]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_13]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_15]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41659,19 +41256,19 @@ fn aiur_fn_462( }) } -const INPUT_SIZE_463: usize = 2; -const IN_463: usize = 2; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_460: usize = 2; +const IN_460: usize = 2; +const OUT_460: usize = 1; +fn aiur_fn_460( + inp: [G; IN_460], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -41696,23 +41293,23 @@ fn aiur_fn_463( let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_25]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_25]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_464: usize = 3; -const IN_464: usize = 3; -const OUT_464: usize = 1; -fn aiur_fn_464( - inp: [G; IN_464], +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: [G; IN_461], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_464], ExecError> { +) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41732,15 +41329,15 @@ fn aiur_fn_464( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_464] = [__v_11]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_11]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41753,16 +41350,16 @@ fn aiur_fn_464( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_11]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_464] = [__v_11]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41771,57 +41368,57 @@ fn aiur_fn_464( }) } -const INPUT_SIZE_465: usize = 3; -const IN_465: usize = 3; -const OUT_465: usize = 1; -fn aiur_fn_465( - inp: [G; IN_465], +const INPUT_SIZE_462: usize = 3; +const IN_462: usize = 3; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_465], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_6]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_6]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_7]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_7]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_466: usize = 1; -const IN_466: usize = 1; -const OUT_466: usize = 1; -fn aiur_fn_466( - inp: [G; IN_466], +const INPUT_SIZE_463: usize = 1; +const IN_463: usize = 1; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_466], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41831,7 +41428,7 @@ fn aiur_fn_466( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41855,7 +41452,7 @@ fn aiur_fn_466( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -41875,114 +41472,114 @@ fn aiur_fn_466( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_466] = [__v_36]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_36]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_36]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_22]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_22]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_20]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_20]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_20]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_20]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_7]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_7]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_467: usize = 3; -const IN_467: usize = 3; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_464: usize = 3; +const IN_464: usize = 3; +const OUT_464: usize = 1; +fn aiur_fn_464( + inp: [G; IN_464], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_5]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_5]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_467] = [__v_6]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_6]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_468: usize = 4; -const IN_468: usize = 4; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_465: usize = 4; +const IN_465: usize = 4; +const OUT_465: usize = 1; +fn aiur_fn_465( + inp: [G; IN_465], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -41991,19 +41588,19 @@ fn aiur_fn_468( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -42014,39 +41611,39 @@ fn aiur_fn_468( let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_23]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_23]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_10]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_10]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_469: usize = 2; -const IN_469: usize = 2; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_466: usize = 2; +const IN_466: usize = 2; +const OUT_466: usize = 1; +fn aiur_fn_466( + inp: [G; IN_466], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -42058,52 +41655,52 @@ fn aiur_fn_469( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_469] = [__v_11]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_11]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_8]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_8]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_470: usize = 3; -const IN_470: usize = 3; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_467: usize = 3; +const IN_467: usize = 3; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_470] = [__v_3]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_3]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_471: usize = 3; -const IN_471: usize = 3; -const OUT_471: usize = 1; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_468: usize = 3; +const IN_468: usize = 3; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42126,22 +41723,22 @@ fn aiur_fn_471( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42154,16 +41751,16 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42176,30 +41773,30 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42212,31 +41809,31 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42244,10 +41841,10 @@ fn aiur_fn_471( } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42260,31 +41857,31 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_14]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_14]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42297,38 +41894,38 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_14]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_14]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_7]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_7]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -42339,28 +41936,28 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42375,39 +41972,39 @@ fn aiur_fn_471( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_13]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42419,15 +42016,15 @@ fn aiur_fn_471( }) } -const INPUT_SIZE_472: usize = 4; -const IN_472: usize = 4; -const OUT_472: usize = 3; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_469: usize = 4; +const IN_469: usize = 4; +const OUT_469: usize = 3; +fn aiur_fn_469( + inp: [G; IN_469], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42436,8 +42033,8 @@ fn aiur_fn_472( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_4, __v_0, __v_1]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_4, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -42445,46 +42042,46 @@ fn aiur_fn_472( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_472] = [__v_5, __v_0, __v_1]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_5, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42492,21 +42089,21 @@ fn aiur_fn_472( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42521,15 +42118,15 @@ fn aiur_fn_472( }) } -const INPUT_SIZE_473: usize = 12; -const IN_473: usize = 12; -const OUT_473: usize = 1; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_470: usize = 12; +const IN_470: usize = 12; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: [G; IN_470], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42545,29 +42142,29 @@ fn aiur_fn_473( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_473] = [__v_5]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_5]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_473] = [__v_12]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_12]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 6; -const IN_474: usize = 6; -const OUT_474: usize = 3; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_471: usize = 6; +const IN_471: usize = 6; +const OUT_471: usize = 3; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42575,7 +42172,7 @@ fn aiur_fn_474( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -42590,7 +42187,7 @@ fn aiur_fn_474( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -42605,26 +42202,26 @@ fn aiur_fn_474( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_474] = [__v_34, __v_2, __v_3]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_2, __v_3]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42632,49 +42229,49 @@ fn aiur_fn_474( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_37, __v_38, __v_39]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_37, __v_38, __v_39]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42687,176 +42284,176 @@ fn aiur_fn_474( }) } -const INPUT_SIZE_475: usize = 4; -const IN_475: usize = 4; -const OUT_475: usize = 3; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_472: usize = 4; +const IN_472: usize = 4; +const OUT_472: usize = 3; +fn aiur_fn_472( + inp: [G; IN_472], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_475] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_476: usize = 4; -const IN_476: usize = 4; -const OUT_476: usize = 3; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_473: usize = 4; +const IN_473: usize = 4; +const OUT_473: usize = 3; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], ExecError> { +) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_477: usize = 4; -const IN_477: usize = 4; -const OUT_477: usize = 3; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_474: usize = 4; +const IN_474: usize = 4; +const OUT_474: usize = 3; +fn aiur_fn_474( + inp: [G; IN_474], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], ExecError> { +) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_478: usize = 5; -const IN_478: usize = 5; -const OUT_478: usize = 3; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_475: usize = 5; +const IN_475: usize = 5; +const OUT_475: usize = 3; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], ExecError> { +) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_478] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42871,35 +42468,35 @@ fn aiur_fn_478( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_478] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42910,38 +42507,38 @@ fn aiur_fn_478( }) } -const INPUT_SIZE_479: usize = 5; -const IN_479: usize = 5; -const OUT_479: usize = 3; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_476: usize = 5; +const IN_476: usize = 5; +const OUT_476: usize = 3; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], ExecError> { +) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42956,35 +42553,35 @@ fn aiur_fn_479( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42995,24 +42592,24 @@ fn aiur_fn_479( }) } -const INPUT_SIZE_480: usize = 4; -const IN_480: usize = 4; -const OUT_480: usize = 3; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_477: usize = 4; +const IN_477: usize = 4; +const OUT_477: usize = 3; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], ExecError> { +) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -43021,23 +42618,23 @@ fn aiur_fn_480( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43047,18 +42644,18 @@ fn aiur_fn_480( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43067,15 +42664,15 @@ fn aiur_fn_480( }) } -const INPUT_SIZE_481: usize = 12; -const IN_481: usize = 12; -const OUT_481: usize = 1; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_478: usize = 12; +const IN_478: usize = 12; +const OUT_478: usize = 1; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], ExecError> { +) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43092,39 +42689,39 @@ fn aiur_fn_481( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_481] = [__v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_481] = [__v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_482: usize = 2; -const IN_482: usize = 2; -const OUT_482: usize = 2; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_479: usize = 2; +const IN_479: usize = 2; +const OUT_479: usize = 2; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], ExecError> { +) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43134,9 +42731,9 @@ fn aiur_fn_482( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43146,7 +42743,7 @@ fn aiur_fn_482( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -43154,50 +42751,50 @@ fn aiur_fn_482( let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_482] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_17, __v_0]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_17, __v_0]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_15, __v_8]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_15, __v_8]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_8, __v_0]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_8, __v_0]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_483: usize = 1; -const IN_483: usize = 1; -const OUT_483: usize = 2; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_480: usize = 1; +const IN_480: usize = 1; +const OUT_480: usize = 2; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_483], ExecError> { +) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43207,7 +42804,7 @@ fn aiur_fn_483( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -43224,79 +42821,79 @@ fn aiur_fn_483( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_20, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_20, __v_0]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_7, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_7, __v_0]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_484: usize = 3; -const IN_484: usize = 3; -const OUT_484: usize = 1; -fn aiur_fn_484( - inp: [G; IN_484], +const INPUT_SIZE_481: usize = 3; +const IN_481: usize = 3; +const OUT_481: usize = 1; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_484], ExecError> { +) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_7]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_7]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_7]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_7]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -43311,7 +42908,7 @@ fn aiur_fn_484( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -43326,27 +42923,27 @@ fn aiur_fn_484( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43354,16 +42951,16 @@ fn aiur_fn_484( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_37]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43379,18 +42976,18 @@ fn aiur_fn_484( }) } -const INPUT_SIZE_485: usize = 1; -const IN_485: usize = 1; -const OUT_485: usize = 2; -fn aiur_fn_485( - inp: [G; IN_485], +const INPUT_SIZE_482: usize = 1; +const IN_482: usize = 1; +const OUT_482: usize = 2; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_485], ExecError> { +) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43401,8 +42998,8 @@ fn aiur_fn_485( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_485] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43440,23 +43037,23 @@ fn aiur_fn_485( let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_485] = [__v_39, __v_40]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_39, __v_40]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_486: usize = 14; -const IN_486: usize = 14; -const OUT_486: usize = 2; -fn aiur_fn_486( - inp: [G; IN_486], +const INPUT_SIZE_483: usize = 14; +const IN_483: usize = 14; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_486], ExecError> { +) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43474,154 +43071,154 @@ fn aiur_fn_486( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_14, __v_0]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_14, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_487: usize = 2; -const IN_487: usize = 2; -const OUT_487: usize = 1; -fn aiur_fn_487( - inp: [G; IN_487], +const INPUT_SIZE_484: usize = 2; +const IN_484: usize = 2; +const OUT_484: usize = 1; +fn aiur_fn_484( + inp: [G; IN_484], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { +) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_6]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_6]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_3]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_3]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_488: usize = 3; -const IN_488: usize = 3; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_485: usize = 3; +const IN_485: usize = 3; +const OUT_485: usize = 1; +fn aiur_fn_485( + inp: [G; IN_485], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_8]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_8]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_14]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_14]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_489: usize = 2; -const IN_489: usize = 2; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_486: usize = 2; +const IN_486: usize = 2; +const OUT_486: usize = 1; +fn aiur_fn_486( + inp: [G; IN_486], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], ExecError> { +) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43632,15 +43229,15 @@ fn aiur_fn_489( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_10]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_10]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -43648,16 +43245,16 @@ fn aiur_fn_489( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_12]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -43672,91 +43269,91 @@ fn aiur_fn_489( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_22]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_22]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_12]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_12]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_13]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_13]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_9]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_9]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_6]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_6]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_6]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_6]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43766,15 +43363,15 @@ fn aiur_fn_489( }) } -const INPUT_SIZE_490: usize = 4; -const IN_490: usize = 4; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_487: usize = 4; +const IN_487: usize = 4; +const OUT_487: usize = 1; +fn aiur_fn_487( + inp: [G; IN_487], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43786,20 +43383,20 @@ fn aiur_fn_490( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_490] = [__v_0]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_0]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_9]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_9]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43812,7 +43409,7 @@ fn aiur_fn_490( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43820,24 +43417,24 @@ fn aiur_fn_490( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_15]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_15]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43845,14 +43442,14 @@ fn aiur_fn_490( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -43861,16 +43458,16 @@ fn aiur_fn_490( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_23]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_23]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43887,43 +43484,43 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 2; -const IN_491: usize = 2; -const OUT_491: usize = 1; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_488: usize = 2; +const IN_488: usize = 2; +const OUT_488: usize = 1; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_8]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_8]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_8]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_8]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43933,23 +43530,23 @@ fn aiur_fn_491( }) } -const INPUT_SIZE_492: usize = 4; -const IN_492: usize = 4; -const OUT_492: usize = 1; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_489: usize = 4; +const IN_489: usize = 4; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -43961,10 +43558,10 @@ fn aiur_fn_492( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_13]; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_13]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43974,29 +43571,29 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 3; -const IN_493: usize = 3; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_490: usize = 3; +const IN_490: usize = 3; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], ExecError> { +) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_3]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_3]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -44009,15 +43606,15 @@ fn aiur_fn_493( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_12]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_12]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_493] = [__v_3]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_3]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44026,54 +43623,54 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 3; -const IN_494: usize = 3; -const OUT_494: usize = 0; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_491: usize = 3; +const IN_491: usize = 3; +const OUT_491: usize = 0; +fn aiur_fn_491( + inp: [G; IN_491], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_494] = []; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = []; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } - let __ret: [G; OUT_494] = []; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = []; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_495: usize = 4; -const IN_495: usize = 4; -const OUT_495: usize = 0; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_492: usize = 4; +const IN_492: usize = 4; +const OUT_492: usize = 0; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], ExecError> { +) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44081,33 +43678,33 @@ fn aiur_fn_495( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_495] = []; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_495] = []; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } - let __ret: [G; OUT_495] = []; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44116,15 +43713,15 @@ fn aiur_fn_495( }) } -const INPUT_SIZE_496: usize = 7; -const IN_496: usize = 7; -const OUT_496: usize = 1; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_493: usize = 7; +const IN_493: usize = 7; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], ExecError> { +) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44143,24 +43740,24 @@ fn aiur_fn_496( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_496] = [__v_8]; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_493] = [__v_8]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_496] = [__v_18]; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_18]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44172,25 +43769,25 @@ fn aiur_fn_496( }) } -const INPUT_SIZE_497: usize = 4; -const IN_497: usize = 4; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_494: usize = 4; +const IN_494: usize = 4; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], ExecError> { +) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -44200,7 +43797,7 @@ fn aiur_fn_497( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -44221,7 +43818,7 @@ fn aiur_fn_497( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -44242,18 +43839,18 @@ fn aiur_fn_497( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_497] = [__v_45]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = [__v_45]; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44273,21 +43870,21 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 2; -const IN_498: usize = 2; -const OUT_498: usize = 1; -fn aiur_fn_498( - inp: [G; IN_498], +const INPUT_SIZE_495: usize = 2; +const IN_495: usize = 2; +const OUT_495: usize = 1; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], ExecError> { +) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -44296,8 +43893,8 @@ fn aiur_fn_498( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_498] = [__v_5]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = [__v_5]; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44307,28 +43904,175 @@ fn aiur_fn_498( }) } -const INPUT_SIZE_499: usize = 3; -const IN_499: usize = 3; -const OUT_499: usize = 0; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_496: usize = 3; +const IN_496: usize = 3; +const OUT_496: usize = 0; +fn aiur_fn_496( + inp: [G; IN_496], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], ExecError> { +) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } - let __ret: [G; OUT_499] = []; + let __ret: [G; OUT_496] = []; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_497: usize = 0; +const IN_497: usize = 0; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_497], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(69); + let __v_1: G = G::from_u64(96); + let __v_2: G = G::from_u64(197); + let __v_3: G = G::from_u64(241); + let __v_4: G = G::from_u64(33); + let __v_5: G = G::from_u64(165); + let __v_6: G = G::from_u64(66); + let __v_7: G = G::from_u64(242); + let __v_8: G = G::from_u64(194); + let __v_9: G = G::from_u64(51); + let __v_10: G = G::from_u64(98); + let __v_11: G = G::from_u64(111); + let __v_12: G = G::from_u64(78); + let __v_13: G = G::from_u64(246); + let __v_14: G = G::from_u64(253); + let __v_15: G = G::from_u64(216); + let __v_16: G = G::from_u64(243); + let __v_17: G = G::from_u64(110); + let __v_18: G = G::from_u64(190); + let __v_19: G = G::from_u64(151); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(72); + let __v_22: G = G::from_u64(173); + let __v_23: G = G::from_u64(234); + let __v_24: G = G::from_u64(238); + let __v_25: G = G::from_u64(40); + let __v_26: G = G::from_u64(61); + let __v_27: G = G::from_u64(158); + let __v_28: G = G::from_u64(212); + let __v_29: G = G::from_u64(87); + let __v_30: G = G::from_u64(47); + let __v_31: G = G::from_u64(219); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_497] = [__v_32]; + if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_498: usize = 0; +const IN_498: usize = 0; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_498], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(163); + let __v_1: G = G::from_u64(245); + let __v_2: G = G::from_u64(168); + let __v_3: G = G::from_u64(13); + let __v_4: G = G::from_u64(26); + let __v_5: G = G::from_u64(140); + let __v_6: G = G::from_u64(201); + let __v_7: G = G::from_u64(144); + let __v_8: G = G::from_u64(99); + let __v_9: G = G::from_u64(157); + let __v_10: G = G::from_u64(6); + let __v_11: G = G::from_u64(190); + let __v_12: G = G::from_u64(152); + let __v_13: G = G::from_u64(188); + let __v_14: G = G::from_u64(194); + let __v_15: G = G::from_u64(178); + let __v_16: G = G::from_u64(64); + let __v_17: G = G::from_u64(247); + let __v_18: G = G::from_u64(147); + let __v_19: G = G::from_u64(164); + let __v_20: G = G::from_u64(173); + let __v_21: G = G::from_u64(186); + let __v_22: G = G::from_u64(155); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(39); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(184); + let __v_27: G = G::from_u64(4); + let __v_28: G = G::from_u64(166); + let __v_29: G = G::from_u64(254); + let __v_30: G = G::from_u64(51); + let __v_31: G = G::from_u64(118); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_498] = [__v_32]; + if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_499: usize = 0; +const IN_499: usize = 0; +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 = G::from_u64(46); + let __v_1: G = G::from_u64(163); + let __v_2: G = G::from_u64(101); + let __v_3: G = G::from_u64(57); + let __v_4: G = G::from_u64(172); + let __v_5: G = G::from_u64(26); + let __v_6: G = G::from_u64(142); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(34); + let __v_9: G = G::from_u64(169); + let __v_10: G = G::from_u64(13); + let __v_11: G = G::from_u64(139); + let __v_12: G = G::from_u64(112); + let __v_13: G = G::from_u64(221); + let __v_14: G = G::from_u64(182); + let __v_15: G = G::from_u64(244); + let __v_16: G = G::from_u64(219); + let __v_17: G = G::from_u64(70); + let __v_18: G = G::from_u64(176); + let __v_19: G = G::from_u64(206); + let __v_20: G = G::from_u64(25); + let __v_21: G = G::from_u64(239); + let __v_22: G = G::from_u64(228); + let __v_23: G = G::from_u64(225); + let __v_24: G = G::from_u64(196); + let __v_25: G = G::from_u64(71); + let __v_26: G = G::from_u64(146); + let __v_27: G = G::from_u64(254); + let __v_28: G = G::from_u64(237); + let __v_29: G = G::from_u64(157); + let __v_30: G = G::from_u64(126); + let __v_31: G = G::from_u64(143); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_499] = [__v_32]; if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -44344,38 +44088,38 @@ fn aiur_fn_500( unconstrained: bool, ) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(41); - let __v_1: G = G::from_u64(153); - let __v_2: G = G::from_u64(128); - let __v_3: G = G::from_u64(21); - let __v_4: G = G::from_u64(152); - let __v_5: G = G::from_u64(193); - let __v_6: G = G::from_u64(218); - let __v_7: G = G::from_u64(72); - let __v_8: G = G::from_u64(245); - let __v_9: G = G::from_u64(98); - let __v_10: G = G::from_u64(212); - let __v_11: G = G::from_u64(131); - let __v_12: G = G::from_u64(96); - let __v_13: G = G::from_u64(100); - let __v_14: G = G::from_u64(246); - let __v_15: G = G::from_u64(53); - let __v_16: G = G::from_u64(192); - let __v_17: G = G::from_u64(69); - let __v_18: G = G::from_u64(208); - let __v_19: G = G::from_u64(82); - let __v_20: G = G::from_u64(20); - let __v_21: G = G::from_u64(82); - let __v_22: G = G::from_u64(181); - let __v_23: G = G::from_u64(231); - let __v_24: G = G::from_u64(74); - let __v_25: G = G::from_u64(18); - let __v_26: G = G::from_u64(191); - let __v_27: G = G::from_u64(153); - let __v_28: G = G::from_u64(210); - let __v_29: G = G::from_u64(227); - let __v_30: G = G::from_u64(22); - let __v_31: G = G::from_u64(236); + let __v_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_500] = [__v_32]; if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44393,38 +44137,38 @@ fn aiur_fn_501( unconstrained: bool, ) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(27); - let __v_1: G = G::from_u64(172); - let __v_2: G = G::from_u64(4); - let __v_3: G = G::from_u64(23); - let __v_4: G = G::from_u64(86); - let __v_5: G = G::from_u64(237); - let __v_6: G = G::from_u64(34); - let __v_7: G = G::from_u64(215); - let __v_8: G = G::from_u64(59); - let __v_9: G = G::from_u64(188); - let __v_10: G = G::from_u64(172); - let __v_11: G = G::from_u64(132); - let __v_12: G = G::from_u64(154); - let __v_13: G = G::from_u64(148); - let __v_14: G = G::from_u64(242); - let __v_15: G = G::from_u64(70); - let __v_16: G = G::from_u64(238); - let __v_17: G = G::from_u64(38); - let __v_18: G = G::from_u64(150); - let __v_19: G = G::from_u64(153); - let __v_20: G = G::from_u64(159); - let __v_21: G = G::from_u64(175); - let __v_22: G = G::from_u64(53); - let __v_23: G = G::from_u64(25); - let __v_24: G = G::from_u64(64); - let __v_25: G = G::from_u64(70); - let __v_26: G = G::from_u64(141); - let __v_27: G = G::from_u64(150); - let __v_28: G = G::from_u64(41); - let __v_29: G = G::from_u64(112); - let __v_30: G = G::from_u64(202); - let __v_31: G = G::from_u64(42); + let __v_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_501] = [__v_32]; if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44442,38 +44186,38 @@ fn aiur_fn_502( unconstrained: bool, ) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(18); - let __v_1: G = G::from_u64(243); - let __v_2: G = G::from_u64(134); - let __v_3: G = G::from_u64(244); - let __v_4: G = G::from_u64(134); - let __v_5: G = G::from_u64(145); - let __v_6: G = G::from_u64(59); - let __v_7: G = G::from_u64(17); - let __v_8: G = G::from_u64(181); - let __v_9: G = G::from_u64(71); - let __v_10: G = G::from_u64(60); - let __v_11: G = G::from_u64(178); - let __v_12: G = G::from_u64(83); - let __v_13: G = G::from_u64(131); - let __v_14: G = G::from_u64(48); - let __v_15: G = G::from_u64(213); - let __v_16: G = G::from_u64(31); - let __v_17: G = G::from_u64(37); - let __v_18: G = G::from_u64(174); - let __v_19: G = G::from_u64(236); - let __v_20: G = G::from_u64(127); - let __v_21: G = G::from_u64(45); - let __v_22: G = G::from_u64(125); - let __v_23: G = G::from_u64(107); - let __v_24: G = G::from_u64(150); - let __v_25: G = G::from_u64(144); - let __v_26: G = G::from_u64(67); - let __v_27: G = G::from_u64(41); - let __v_28: G = G::from_u64(199); - let __v_29: G = G::from_u64(139); - let __v_30: G = G::from_u64(105); - let __v_31: G = G::from_u64(103); + let __v_0: G = G::from_u64(4); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(154); + let __v_3: G = G::from_u64(209); + let __v_4: G = G::from_u64(72); + let __v_5: G = G::from_u64(158); + let __v_6: G = G::from_u64(118); + let __v_7: G = G::from_u64(159); + let __v_8: G = G::from_u64(210); + let __v_9: G = G::from_u64(149); + let __v_10: G = G::from_u64(213); + let __v_11: G = G::from_u64(140); + let __v_12: G = G::from_u64(182); + let __v_13: G = G::from_u64(74); + let __v_14: G = G::from_u64(116); + let __v_15: G = G::from_u64(5); + let __v_16: G = G::from_u64(232); + let __v_17: G = G::from_u64(111); + let __v_18: G = G::from_u64(120); + let __v_19: G = G::from_u64(129); + let __v_20: G = G::from_u64(181); + let __v_21: G = G::from_u64(231); + let __v_22: G = G::from_u64(194); + let __v_23: G = G::from_u64(45); + let __v_24: G = G::from_u64(119); + let __v_25: G = G::from_u64(223); + let __v_26: G = G::from_u64(72); + let __v_27: G = G::from_u64(105); + let __v_28: G = G::from_u64(21); + let __v_29: G = G::from_u64(213); + let __v_30: G = G::from_u64(142); + let __v_31: G = G::from_u64(179); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_502] = [__v_32]; if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44491,38 +44235,38 @@ fn aiur_fn_503( unconstrained: bool, ) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(123); - let __v_1: G = G::from_u64(63); - let __v_2: G = G::from_u64(106); - let __v_3: G = G::from_u64(110); - let __v_4: G = G::from_u64(235); - let __v_5: G = G::from_u64(243); - let __v_6: G = G::from_u64(42); - let __v_7: G = G::from_u64(157); - let __v_8: G = G::from_u64(90); - let __v_9: G = G::from_u64(84); - let __v_10: G = G::from_u64(48); - let __v_11: G = G::from_u64(94); - let __v_12: G = G::from_u64(105); - let __v_13: G = G::from_u64(61); - let __v_14: G = G::from_u64(206); - let __v_15: G = G::from_u64(96); - let __v_16: G = G::from_u64(81); - let __v_17: G = G::from_u64(26); - let __v_18: G = G::from_u64(254); - let __v_19: G = G::from_u64(177); - let __v_20: G = G::from_u64(250); - let __v_21: G = G::from_u64(17); - let __v_22: G = G::from_u64(188); - let __v_23: G = G::from_u64(136); - let __v_24: G = G::from_u64(68); - let __v_25: G = G::from_u64(165); - let __v_26: G = G::from_u64(194); - let __v_27: G = G::from_u64(27); - let __v_28: G = G::from_u64(191); - let __v_29: G = G::from_u64(211); - let __v_30: G = G::from_u64(33); - let __v_31: G = G::from_u64(76); + let __v_0: G = G::from_u64(125); + let __v_1: G = G::from_u64(175); + let __v_2: G = G::from_u64(170); + let __v_3: G = G::from_u64(21); + let __v_4: G = G::from_u64(30); + let __v_5: G = G::from_u64(217); + let __v_6: G = G::from_u64(11); + let __v_7: G = G::from_u64(10); + let __v_8: G = G::from_u64(178); + let __v_9: G = G::from_u64(127); + let __v_10: G = G::from_u64(2); + let __v_11: G = G::from_u64(121); + let __v_12: G = G::from_u64(185); + let __v_13: G = G::from_u64(56); + let __v_14: G = G::from_u64(58); + let __v_15: G = G::from_u64(184); + let __v_16: G = G::from_u64(171); + let __v_17: G = G::from_u64(232); + let __v_18: G = G::from_u64(96); + let __v_19: G = G::from_u64(44); + let __v_20: G = G::from_u64(102); + let __v_21: G = G::from_u64(53); + let __v_22: G = G::from_u64(202); + let __v_23: G = G::from_u64(25); + let __v_24: G = G::from_u64(31); + let __v_25: G = G::from_u64(40); + let __v_26: G = G::from_u64(203); + let __v_27: G = G::from_u64(183); + let __v_28: G = G::from_u64(171); + let __v_29: G = G::from_u64(166); + let __v_30: G = G::from_u64(175); + let __v_31: G = G::from_u64(221); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_503] = [__v_32]; if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44540,38 +44284,38 @@ fn aiur_fn_504( unconstrained: bool, ) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(171); - let __v_1: G = G::from_u64(20); - let __v_2: G = G::from_u64(112); - let __v_3: G = G::from_u64(25); - let __v_4: G = G::from_u64(100); - let __v_5: G = G::from_u64(25); - let __v_6: G = G::from_u64(247); - let __v_7: G = G::from_u64(29); - let __v_8: G = G::from_u64(6); - let __v_9: G = G::from_u64(254); - let __v_10: G = G::from_u64(237); - let __v_11: G = G::from_u64(156); - let __v_12: G = G::from_u64(203); - let __v_13: G = G::from_u64(140); - let __v_14: G = G::from_u64(29); - let __v_15: G = G::from_u64(3); - let __v_16: G = G::from_u64(103); - let __v_17: G = G::from_u64(69); - let __v_18: G = G::from_u64(40); - let __v_19: G = G::from_u64(236); - let __v_20: G = G::from_u64(3); - let __v_21: G = G::from_u64(1); - let __v_22: G = G::from_u64(43); - let __v_23: G = G::from_u64(9); - let __v_24: G = G::from_u64(91); - let __v_25: G = G::from_u64(173); - let __v_26: G = G::from_u64(193); - let __v_27: G = G::from_u64(105); - let __v_28: G = G::from_u64(212); - let __v_29: G = G::from_u64(141); - let __v_30: G = G::from_u64(3); - let __v_31: G = G::from_u64(208); + let __v_0: G = G::from_u64(248); + let __v_1: G = G::from_u64(49); + let __v_2: G = G::from_u64(57); + let __v_3: G = G::from_u64(113); + let __v_4: G = G::from_u64(187); + let __v_5: G = G::from_u64(165); + let __v_6: G = G::from_u64(238); + let __v_7: G = G::from_u64(140); + let __v_8: G = G::from_u64(129); + let __v_9: G = G::from_u64(69); + let __v_10: G = G::from_u64(84); + let __v_11: G = G::from_u64(176); + let __v_12: G = G::from_u64(192); + let __v_13: G = G::from_u64(68); + let __v_14: G = G::from_u64(122); + let __v_15: G = G::from_u64(16); + let __v_16: G = G::from_u64(193); + let __v_17: G = G::from_u64(41); + let __v_18: G = G::from_u64(180); + let __v_19: G = G::from_u64(25); + let __v_20: G = G::from_u64(69); + let __v_21: G = G::from_u64(172); + let __v_22: G = G::from_u64(95); + let __v_23: G = G::from_u64(184); + let __v_24: G = G::from_u64(23); + let __v_25: G = G::from_u64(195); + let __v_26: G = G::from_u64(252); + let __v_27: G = G::from_u64(123); + let __v_28: G = G::from_u64(152); + let __v_29: G = G::from_u64(178); + let __v_30: G = G::from_u64(58); + let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_504] = [__v_32]; if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44589,38 +44333,38 @@ fn aiur_fn_505( unconstrained: bool, ) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(35); - let __v_1: G = G::from_u64(190); - let __v_2: G = G::from_u64(163); - let __v_3: G = G::from_u64(187); - let __v_4: G = G::from_u64(243); - let __v_5: G = G::from_u64(168); - let __v_6: G = G::from_u64(208); - let __v_7: G = G::from_u64(168); - let __v_8: G = G::from_u64(208); - let __v_9: G = G::from_u64(3); - let __v_10: G = G::from_u64(60); - let __v_11: G = G::from_u64(247); - let __v_12: G = G::from_u64(229); - let __v_13: G = G::from_u64(106); - let __v_14: G = G::from_u64(240); - let __v_15: G = G::from_u64(196); - let __v_16: G = G::from_u64(174); - let __v_17: G = G::from_u64(224); - let __v_18: G = G::from_u64(21); - let __v_19: G = G::from_u64(130); - let __v_20: G = G::from_u64(213); - let __v_21: G = G::from_u64(167); - let __v_22: G = G::from_u64(88); - let __v_23: G = G::from_u64(192); - let __v_24: G = G::from_u64(223); - let __v_25: G = G::from_u64(86); - let __v_26: G = G::from_u64(21); - let __v_27: G = G::from_u64(146); - let __v_28: G = G::from_u64(156); - let __v_29: G = G::from_u64(166); - let __v_30: G = G::from_u64(32); - let __v_31: G = G::from_u64(77); + let __v_0: G = G::from_u64(122); + let __v_1: G = G::from_u64(236); + let __v_2: G = G::from_u64(194); + let __v_3: G = G::from_u64(6); + let __v_4: G = G::from_u64(113); + let __v_5: G = G::from_u64(77); + let __v_6: G = G::from_u64(100); + let __v_7: G = G::from_u64(181); + let __v_8: G = G::from_u64(23); + let __v_9: G = G::from_u64(122); + let __v_10: G = G::from_u64(203); + let __v_11: G = G::from_u64(117); + let __v_12: G = G::from_u64(58); + let __v_13: G = G::from_u64(40); + let __v_14: G = G::from_u64(94); + let __v_15: G = G::from_u64(103); + let __v_16: G = G::from_u64(10); + let __v_17: G = G::from_u64(145); + let __v_18: G = G::from_u64(138); + let __v_19: G = G::from_u64(26); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(143); + let __v_23: G = G::from_u64(87); + let __v_24: G = G::from_u64(70); + let __v_25: G = G::from_u64(15); + let __v_26: G = G::from_u64(119); + let __v_27: G = G::from_u64(111); + let __v_28: G = G::from_u64(23); + let __v_29: G = G::from_u64(183); + let __v_30: G = G::from_u64(173); + let __v_31: G = G::from_u64(194); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_505] = [__v_32]; if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44638,38 +44382,38 @@ fn aiur_fn_506( unconstrained: bool, ) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(190); - let __v_1: G = G::from_u64(80); - let __v_2: G = G::from_u64(182); - let __v_3: G = G::from_u64(5); - let __v_4: G = G::from_u64(61); - let __v_5: G = G::from_u64(240); - let __v_6: G = G::from_u64(176); - let __v_7: G = G::from_u64(116); - let __v_8: G = G::from_u64(56); - let __v_9: G = G::from_u64(164); - let __v_10: G = G::from_u64(172); - let __v_11: G = G::from_u64(46); - let __v_12: G = G::from_u64(239); - let __v_13: G = G::from_u64(215); - let __v_14: G = G::from_u64(10); - let __v_15: G = G::from_u64(17); - let __v_16: G = G::from_u64(112); - let __v_17: G = G::from_u64(139); - let __v_18: G = G::from_u64(12); - let __v_19: G = G::from_u64(187); - let __v_20: G = G::from_u64(15); - let __v_21: G = G::from_u64(201); - let __v_22: G = G::from_u64(5); - let __v_23: G = G::from_u64(100); - let __v_24: G = G::from_u64(186); - let __v_25: G = G::from_u64(254); - let __v_26: G = G::from_u64(230); - let __v_27: G = G::from_u64(225); - let __v_28: G = G::from_u64(101); - let __v_29: G = G::from_u64(97); - let __v_30: G = G::from_u64(93); - let __v_31: G = G::from_u64(232); + let __v_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_506] = [__v_32]; if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44687,38 +44431,38 @@ fn aiur_fn_507( unconstrained: bool, ) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(196); - let __v_1: G = G::from_u64(137); - let __v_2: G = G::from_u64(50); - let __v_3: G = G::from_u64(145); - let __v_4: G = G::from_u64(151); - let __v_5: G = G::from_u64(181); - let __v_6: G = G::from_u64(154); - let __v_7: G = G::from_u64(4); - let __v_8: G = G::from_u64(13); - let __v_9: G = G::from_u64(30); - let __v_10: G = G::from_u64(94); - let __v_11: G = G::from_u64(77); - let __v_12: G = G::from_u64(93); - let __v_13: G = G::from_u64(230); + 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(112); - let __v_16: G = G::from_u64(71); - let __v_17: G = G::from_u64(141); - let __v_18: G = G::from_u64(30); - let __v_19: G = G::from_u64(164); - let __v_20: G = G::from_u64(249); - let __v_21: G = G::from_u64(117); - let __v_22: G = G::from_u64(1); - let __v_23: G = G::from_u64(118); - let __v_24: G = G::from_u64(2); - let __v_25: G = G::from_u64(109); - let __v_26: G = G::from_u64(210); - let __v_27: G = G::from_u64(191); - let __v_28: G = G::from_u64(133); - let __v_29: G = G::from_u64(147); - let __v_30: G = G::from_u64(191); - let __v_31: G = G::from_u64(34); + let __v_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_507] = [__v_32]; if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44736,38 +44480,38 @@ fn aiur_fn_508( unconstrained: bool, ) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(14); - let __v_1: G = G::from_u64(181); - let __v_2: G = G::from_u64(185); - let __v_3: G = G::from_u64(135); - let __v_4: G = G::from_u64(241); - let __v_5: G = G::from_u64(33); - let __v_6: G = G::from_u64(36); - let __v_7: G = G::from_u64(190); - let __v_8: G = G::from_u64(5); - let __v_9: G = G::from_u64(117); - let __v_10: G = G::from_u64(164); - let __v_11: G = G::from_u64(119); - let __v_12: G = G::from_u64(204); - let __v_13: G = G::from_u64(10); - let __v_14: G = G::from_u64(83); - let __v_15: G = G::from_u64(85); - let __v_16: G = G::from_u64(22); - let __v_17: G = G::from_u64(162); - let __v_18: G = G::from_u64(75); - let __v_19: G = G::from_u64(10); + let __v_0: G = G::from_u64(15); + let __v_1: G = G::from_u64(83); + let __v_2: G = G::from_u64(188); + let __v_3: G = G::from_u64(87); + let __v_4: G = G::from_u64(104); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(50); + let __v_7: G = G::from_u64(170); + let __v_8: G = G::from_u64(104); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(220); + let __v_11: G = G::from_u64(135); + let __v_12: G = G::from_u64(98); + let __v_13: G = G::from_u64(147); + let __v_14: G = G::from_u64(75); + let __v_15: G = G::from_u64(105); + let __v_16: G = G::from_u64(4); + let __v_17: G = G::from_u64(157); + let __v_18: G = G::from_u64(179); + let __v_19: G = G::from_u64(231); let __v_20: G = G::from_u64(229); - let __v_21: G = G::from_u64(206); - let __v_22: G = G::from_u64(221); - let __v_23: G = G::from_u64(190); - let __v_24: G = G::from_u64(226); - let __v_25: G = G::from_u64(212); - let __v_26: G = G::from_u64(114); - let __v_27: G = G::from_u64(118); - let __v_28: G = G::from_u64(90); - let __v_29: G = G::from_u64(237); - let __v_30: G = G::from_u64(41); - let __v_31: G = G::from_u64(156); + let __v_21: G = G::from_u64(116); + let __v_22: G = G::from_u64(18); + let __v_23: G = G::from_u64(198); + let __v_24: G = G::from_u64(144); + let __v_25: G = G::from_u64(77); + let __v_26: G = G::from_u64(209); + let __v_27: G = G::from_u64(168); + let __v_28: G = G::from_u64(185); + let __v_29: G = G::from_u64(207); + let __v_30: G = G::from_u64(244); + let __v_31: G = G::from_u64(248); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_508] = [__v_32]; if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44785,38 +44529,38 @@ fn aiur_fn_509( unconstrained: bool, ) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(230); - let __v_1: G = G::from_u64(235); - 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_0: G = G::from_u64(14); + let __v_1: G = G::from_u64(95); + let __v_2: G = G::from_u64(112); + let __v_3: G = G::from_u64(239); + let __v_4: G = G::from_u64(218); + let __v_5: G = G::from_u64(5); + let __v_6: G = G::from_u64(152); + let __v_7: G = G::from_u64(24); + let __v_8: G = G::from_u64(40); + let __v_9: G = G::from_u64(25); + let __v_10: G = G::from_u64(161); + let __v_11: G = G::from_u64(10); + let __v_12: G = G::from_u64(35); + let __v_13: G = G::from_u64(135); + let __v_14: G = G::from_u64(150); + let __v_15: G = G::from_u64(70); + let __v_16: G = G::from_u64(45); + let __v_17: G = G::from_u64(235); + let __v_18: G = G::from_u64(192); + let __v_19: G = G::from_u64(95); + let __v_20: G = G::from_u64(64); + let __v_21: G = G::from_u64(136); + let __v_22: G = G::from_u64(129); + let __v_23: G = G::from_u64(23); + let __v_24: G = G::from_u64(209); + let __v_25: G = G::from_u64(25); + let __v_26: G = G::from_u64(105); + let __v_27: G = G::from_u64(146); + let __v_28: G = G::from_u64(185); + let __v_29: G = G::from_u64(66); + let __v_30: G = G::from_u64(63); + let __v_31: G = G::from_u64(174); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_509] = [__v_32]; if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44834,38 +44578,38 @@ fn aiur_fn_510( unconstrained: bool, ) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(227); - let __v_1: G = G::from_u64(8); - let __v_2: G = G::from_u64(3); - let __v_3: G = G::from_u64(91); - let __v_4: G = G::from_u64(223); - let __v_5: G = G::from_u64(40); - let __v_6: G = G::from_u64(12); - let __v_7: G = G::from_u64(146); - let __v_8: G = G::from_u64(117); - let __v_9: G = G::from_u64(86); - let __v_10: G = G::from_u64(130); - let __v_11: G = G::from_u64(77); - let __v_12: G = G::from_u64(106); - let __v_13: G = G::from_u64(159); - let __v_14: G = G::from_u64(146); - let __v_15: G = G::from_u64(54); - let __v_16: G = G::from_u64(161); - let __v_17: G = G::from_u64(72); - let __v_18: G = G::from_u64(118); - let __v_19: G = G::from_u64(81); - let __v_20: G = G::from_u64(240); - let __v_21: G = G::from_u64(5); - let __v_22: G = G::from_u64(154); - let __v_23: G = G::from_u64(125); - let __v_24: G = G::from_u64(243); - let __v_25: G = G::from_u64(189); - let __v_26: G = G::from_u64(168); - let __v_27: G = G::from_u64(91); - let __v_28: G = G::from_u64(51); - let __v_29: G = G::from_u64(31); - let __v_30: G = G::from_u64(103); - let __v_31: G = G::from_u64(230); + let __v_0: G = G::from_u64(206); + let __v_1: G = G::from_u64(19); + let __v_2: G = G::from_u64(124); + let __v_3: G = G::from_u64(206); + let __v_4: G = G::from_u64(76); + let __v_5: G = G::from_u64(26); + let __v_6: G = G::from_u64(73); + let __v_7: G = G::from_u64(50); + let __v_8: G = G::from_u64(58); + let __v_9: G = G::from_u64(120); + let __v_10: G = G::from_u64(143); + let __v_11: G = G::from_u64(22); + let __v_12: G = G::from_u64(119); + let __v_13: G = G::from_u64(169); + let __v_14: G = G::from_u64(214); + let __v_15: G = G::from_u64(161); + let __v_16: G = G::from_u64(212); + let __v_17: G = G::from_u64(169); + let __v_18: G = G::from_u64(54); + let __v_19: G = G::from_u64(17); + let __v_20: G = G::from_u64(21); + let __v_21: G = G::from_u64(136); + let __v_22: G = G::from_u64(8); + let __v_23: G = G::from_u64(53); + let __v_24: G = G::from_u64(137); + let __v_25: G = G::from_u64(186); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(43); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(16); + let __v_31: G = G::from_u64(140); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_510] = [__v_32]; if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44873,8 +44617,8 @@ fn aiur_fn_510( }) } -const INPUT_SIZE_511: usize = 0; -const IN_511: usize = 0; +const INPUT_SIZE_511: usize = 1; +const IN_511: usize = 1; const OUT_511: usize = 1; fn aiur_fn_511( inp: [G; IN_511], @@ -44882,230 +44626,83 @@ fn aiur_fn_511( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_511], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(122); - let __v_1: G = G::from_u64(6); - let __v_2: G = G::from_u64(73); - let __v_3: G = G::from_u64(109); - let __v_4: G = G::from_u64(7); - let __v_5: G = G::from_u64(181); - let __v_6: G = G::from_u64(151); - let __v_7: G = G::from_u64(16); - let __v_8: G = G::from_u64(52); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(95); - let __v_11: G = G::from_u64(101); - let __v_12: G = G::from_u64(120); - let __v_13: G = G::from_u64(81); - let __v_14: G = G::from_u64(164); - let __v_15: G = G::from_u64(238); - let __v_16: G = G::from_u64(161); - let __v_17: G = G::from_u64(245); - let __v_18: G = G::from_u64(148); - let __v_19: G = G::from_u64(146); - let __v_20: G = G::from_u64(165); - let __v_21: G = G::from_u64(183); - let __v_22: G = G::from_u64(222); - let __v_23: G = G::from_u64(63); - let __v_24: G = G::from_u64(81); - let __v_25: G = G::from_u64(171); - let __v_26: G = G::from_u64(188); - let __v_27: G = G::from_u64(132); - let __v_28: G = G::from_u64(249); - let __v_29: G = G::from_u64(188); - let __v_30: G = G::from_u64(29); - let __v_31: G = G::from_u64(23); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_511] = [__v_32]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_512: usize = 0; -const IN_512: usize = 0; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(20); - let __v_1: G = G::from_u64(236); - let __v_2: G = G::from_u64(206); - let __v_3: G = G::from_u64(225); - let __v_4: G = G::from_u64(222); - let __v_5: G = G::from_u64(186); - let __v_6: G = G::from_u64(5); - let __v_7: G = G::from_u64(233); - let __v_8: G = G::from_u64(68); - let __v_9: G = G::from_u64(59); - let __v_10: G = G::from_u64(209); - let __v_11: G = G::from_u64(105); - let __v_12: G = G::from_u64(208); - let __v_13: G = G::from_u64(14); - let __v_14: G = G::from_u64(214); - let __v_15: G = G::from_u64(52); - let __v_16: G = G::from_u64(23); - let __v_17: G = G::from_u64(14); - let __v_18: G = G::from_u64(50); - let __v_19: G = G::from_u64(70); - let __v_20: G = G::from_u64(179); - let __v_21: G = G::from_u64(121); - let __v_22: G = G::from_u64(33); - let __v_23: G = G::from_u64(25); - let __v_24: G = G::from_u64(158); - let __v_25: G = G::from_u64(219); - let __v_26: G = G::from_u64(186); - let __v_27: G = G::from_u64(211); - let __v_28: G = G::from_u64(246); - let __v_29: G = G::from_u64(125); - let __v_30: G = G::from_u64(181); - let __v_31: G = G::from_u64(180); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_512] = [__v_32]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_513: usize = 0; -const IN_513: usize = 0; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(173); - let __v_1: G = G::from_u64(50); - let __v_2: G = G::from_u64(192); - let __v_3: G = G::from_u64(93); - let __v_4: G = G::from_u64(126); - let __v_5: G = G::from_u64(60); - let __v_6: G = G::from_u64(93); - let __v_7: G = G::from_u64(223); - let __v_8: G = G::from_u64(78); - let __v_9: G = G::from_u64(76); - let __v_10: G = G::from_u64(133); - let __v_11: G = G::from_u64(207); - let __v_12: G = G::from_u64(143); - let __v_13: G = G::from_u64(96); - let __v_14: G = G::from_u64(216); - let __v_15: G = G::from_u64(62); - let __v_16: G = G::from_u64(15); - let __v_17: G = G::from_u64(186); - let __v_18: G = G::from_u64(85); - let __v_19: G = G::from_u64(226); - let __v_20: G = G::from_u64(103); - let __v_21: G = G::from_u64(107); - let __v_22: G = G::from_u64(248); - let __v_23: G = G::from_u64(161); - let __v_24: G = G::from_u64(230); - let __v_25: G = G::from_u64(8); - let __v_26: G = G::from_u64(219); - let __v_27: G = G::from_u64(84); - let __v_28: G = G::from_u64(177); - let __v_29: G = G::from_u64(103); - let __v_30: G = G::from_u64(201); - let __v_31: G = G::from_u64(250); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_32]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_514: usize = 1; -const IN_514: usize = 1; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_3]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_3]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_5]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_5]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_7]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_7]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_9]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_9]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_11]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_11]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_13]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_13]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_514] = [__v_13]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_13]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45122,56 +44719,56 @@ fn aiur_fn_514( }) } -const INPUT_SIZE_515: usize = 1; -const IN_515: usize = 1; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_512: usize = 1; +const IN_512: usize = 1; +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_515], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_3]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_3]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_5]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_5]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_7]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_7]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_515] = [__v_7]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_7]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45182,15 +44779,15 @@ fn aiur_fn_515( }) } -const INPUT_SIZE_516: usize = 1; -const IN_516: usize = 1; -const OUT_516: usize = 3; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_513: usize = 1; +const IN_513: usize = 1; +const OUT_513: usize = 3; +fn aiur_fn_513( + inp: [G; IN_513], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -45207,13 +44804,13 @@ fn aiur_fn_516( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -45223,8 +44820,8 @@ fn aiur_fn_516( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_14, __v_15, __v_18]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_14, __v_15, __v_18]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45238,8 +44835,8 @@ fn aiur_fn_516( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_516] = [__v_18, __v_12, __v_16]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_12, __v_16]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45248,8 +44845,8 @@ fn aiur_fn_516( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45260,8 +44857,8 @@ fn aiur_fn_516( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45274,8 +44871,8 @@ fn aiur_fn_516( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45286,34 +44883,34 @@ fn aiur_fn_516( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_514: usize = 2; +const IN_514: usize = 2; +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_517], 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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -45333,27 +44930,27 @@ fn aiur_fn_517( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_15]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_15]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_518: usize = 4; -const IN_518: usize = 4; -const OUT_518: usize = 2; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_515: usize = 4; +const IN_515: usize = 4; +const OUT_515: usize = 2; +fn aiur_fn_515( + inp: [G; IN_515], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45364,24 +44961,24 @@ fn aiur_fn_518( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -45392,26 +44989,26 @@ fn aiur_fn_518( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_518] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_518] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45420,15 +45017,15 @@ fn aiur_fn_518( }) } -const INPUT_SIZE_519: usize = 6; -const IN_519: usize = 6; -const OUT_519: usize = 2; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_516: usize = 6; +const IN_516: usize = 6; +const OUT_516: usize = 2; +fn aiur_fn_516( + inp: [G; IN_516], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], 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]; @@ -45436,25 +45033,25 @@ fn aiur_fn_519( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); @@ -45466,13 +45063,13 @@ fn aiur_fn_519( let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_519] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45481,8 +45078,8 @@ fn aiur_fn_519( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45493,29 +45090,29 @@ fn aiur_fn_519( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_520: usize = 4; -const IN_520: usize = 4; -const OUT_520: usize = 2; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_517: usize = 4; +const IN_517: usize = 4; +const OUT_517: usize = 2; +fn aiur_fn_517( + inp: [G; IN_517], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45526,50 +45123,50 @@ fn aiur_fn_520( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45580,28 +45177,28 @@ fn aiur_fn_520( }) } -const INPUT_SIZE_521: usize = 3; -const IN_521: usize = 3; -const OUT_521: usize = 2; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_518: usize = 3; +const IN_518: usize = 3; +const OUT_518: usize = 2; +fn aiur_fn_518( + inp: [G; IN_518], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45611,17 +45208,17 @@ fn aiur_fn_521( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -45632,13 +45229,13 @@ fn aiur_fn_521( let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_521] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45648,15 +45245,15 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 6; -const IN_522: usize = 6; -const OUT_522: usize = 2; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +const OUT_519: usize = 2; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], 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]; @@ -45665,16 +45262,16 @@ fn aiur_fn_522( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45684,12 +45281,12 @@ fn aiur_fn_522( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45699,30 +45296,30 @@ fn aiur_fn_522( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_522] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45737,15 +45334,15 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 9; -const IN_523: usize = 9; -const OUT_523: usize = 2; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_520: usize = 9; +const IN_520: usize = 9; +const OUT_520: usize = 2; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], 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]; @@ -45766,8 +45363,8 @@ fn aiur_fn_523( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45783,12 +45380,12 @@ fn aiur_fn_523( let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); @@ -45797,12 +45394,12 @@ fn aiur_fn_523( let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -45825,12 +45422,12 @@ fn aiur_fn_523( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45839,12 +45436,12 @@ fn aiur_fn_523( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45868,31 +45465,31 @@ fn aiur_fn_523( let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_63, __v_64]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_63, __v_64]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_524: usize = 3; -const IN_524: usize = 3; -const OUT_524: usize = 2; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_521: usize = 3; +const IN_521: usize = 3; +const OUT_521: usize = 2; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45903,16 +45500,16 @@ fn aiur_fn_524( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -45932,7 +45529,7 @@ fn aiur_fn_524( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45941,16 +45538,16 @@ fn aiur_fn_524( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_524] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45961,8 +45558,8 @@ fn aiur_fn_524( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45973,8 +45570,8 @@ fn aiur_fn_524( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45985,8 +45582,8 @@ fn aiur_fn_524( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45997,8 +45594,8 @@ fn aiur_fn_524( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46007,15 +45604,15 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 4; -const IN_525: usize = 4; -const OUT_525: usize = 2; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_522: usize = 4; +const IN_522: usize = 4; +const OUT_522: usize = 2; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], 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]; @@ -46033,12 +45630,12 @@ fn aiur_fn_525( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -46062,18 +45659,18 @@ fn aiur_fn_525( let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -46084,16 +45681,16 @@ fn aiur_fn_525( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_52, __v_56]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_52, __v_56]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); @@ -46107,28 +45704,28 @@ fn aiur_fn_525( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_69, __v_70]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_69, __v_70]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_526: usize = 6; -const IN_526: usize = 6; -const OUT_526: usize = 2; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_523: usize = 6; +const IN_523: usize = 6; +const OUT_523: usize = 2; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], 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]; @@ -46138,12 +45735,12 @@ fn aiur_fn_526( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -46154,18 +45751,18 @@ fn aiur_fn_526( let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -46176,13 +45773,13 @@ fn aiur_fn_526( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_526] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -46197,28 +45794,28 @@ fn aiur_fn_526( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_526] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_527: usize = 2; -const IN_527: usize = 2; -const OUT_527: usize = 1; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_524: usize = 2; +const IN_524: usize = 2; +const OUT_524: usize = 1; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], 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]; @@ -46226,8 +45823,8 @@ fn aiur_fn_527( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_527] = [__v_3]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_3]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46235,14 +45832,14 @@ fn aiur_fn_527( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_527] = [__v_4]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_4]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_527] = [__v_4]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_4]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46254,96 +45851,96 @@ fn aiur_fn_527( }) } -const INPUT_SIZE_528: usize = 2; -const IN_528: usize = 2; -const OUT_528: usize = 1; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_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_528], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_528] = [__v_1]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_1]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_528] = [__v_0]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_0]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_529: usize = 0; -const IN_529: usize = 0; -const OUT_529: usize = 2; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_526: usize = 0; +const IN_526: usize = 0; +const OUT_526: usize = 2; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], ExecError> { +) -> Result<[G; OUT_526], 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_529] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_530: usize = 0; -const IN_530: usize = 0; -const OUT_530: usize = 2; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_527: usize = 0; +const IN_527: usize = 0; +const OUT_527: usize = 2; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], ExecError> { +) -> Result<[G; OUT_527], 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_530] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 0; -const IN_531: usize = 0; -const OUT_531: usize = 2; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_528: usize = 0; +const IN_528: usize = 0; +const OUT_528: usize = 2; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_531], ExecError> { +) -> Result<[G; OUT_528], 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_531] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_532: usize = 4; -const IN_532: usize = 4; -const OUT_532: usize = 2; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_529: usize = 4; +const IN_529: usize = 4; +const OUT_529: usize = 2; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], 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]; @@ -46352,46 +45949,46 @@ fn aiur_fn_532( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_532] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_2, __v_4]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_532] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_533: usize = 1; -const IN_533: usize = 1; -const OUT_533: usize = 2; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_530: usize = 1; +const IN_530: usize = 1; +const OUT_530: usize = 2; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], ExecError> { +) -> Result<[G; OUT_530], 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_533] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_530] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_534: usize = 2; -const IN_534: usize = 2; -const OUT_534: usize = 1; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_531: usize = 2; +const IN_531: usize = 2; +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_534], 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]; @@ -46461,51 +46058,51 @@ fn aiur_fn_534( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_534] = [__v_80]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_531] = [__v_80]; + if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_535: usize = 8; -const IN_535: usize = 8; -const OUT_535: usize = 1; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_532: usize = 8; +const IN_532: usize = 8; +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_535], 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]; @@ -46533,23 +46130,23 @@ fn aiur_fn_535( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_26]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_532] = [__v_26]; + if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_536: usize = 2; -const IN_536: usize = 2; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_533: usize = 2; +const IN_533: usize = 2; +const OUT_533: usize = 1; +fn aiur_fn_533( + inp: [G; IN_533], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], 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]; @@ -46561,26 +46158,26 @@ fn aiur_fn_536( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_536] = [__v_6]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_6]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_8]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_7]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_7]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46592,54 +46189,54 @@ fn aiur_fn_536( }) } -const INPUT_SIZE_537: usize = 3; -const IN_537: usize = 3; -const OUT_537: usize = 2; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_534: usize = 3; +const IN_534: usize = 3; +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_537], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46647,19 +46244,19 @@ fn aiur_fn_537( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_537] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46670,15 +46267,15 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 2; -const IN_538: usize = 2; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_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_538], 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]; @@ -46695,14 +46292,14 @@ fn aiur_fn_538( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46715,21 +46312,21 @@ fn aiur_fn_538( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46742,31 +46339,31 @@ fn aiur_fn_538( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_10]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_10]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46779,37 +46376,37 @@ fn aiur_fn_538( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_10]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_10]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46824,16 +46421,16 @@ fn aiur_fn_538( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46845,15 +46442,15 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 2; -const IN_539: usize = 2; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_536: usize = 2; +const IN_536: usize = 2; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], 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]; @@ -46870,14 +46467,14 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46890,19 +46487,19 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_10]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_10]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46917,15 +46514,15 @@ fn aiur_fn_539( }) } -const INPUT_SIZE_540: usize = 4; -const IN_540: usize = 4; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_537: usize = 4; +const IN_537: usize = 4; +const OUT_537: usize = 1; +fn aiur_fn_537( + inp: [G; IN_537], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], 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]; @@ -46935,16 +46532,16 @@ fn aiur_fn_540( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_4]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_540] = [__v_4]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46956,15 +46553,15 @@ fn aiur_fn_540( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_540] = [__v_4]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_4]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46979,54 +46576,54 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 2; -const IN_541: usize = 2; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_538: usize = 2; +const IN_538: usize = 2; +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_541], ExecError> { +) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_7]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_7]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_541] = [__v_6]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_6]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_542: usize = 2; -const IN_542: usize = 2; -const OUT_542: usize = 1; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], 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]; @@ -47044,8 +46641,8 @@ fn aiur_fn_542( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_542] = [__v_12]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_12]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -47062,14 +46659,14 @@ fn aiur_fn_542( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_542] = [__v_24]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_24]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47084,15 +46681,15 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 16; -const IN_543: usize = 16; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_540: usize = 16; +const IN_540: usize = 16; +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_543], 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]; @@ -47110,51 +46707,51 @@ fn aiur_fn_543( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_30]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_30]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_544: usize = 2; -const IN_544: usize = 2; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_541: usize = 2; +const IN_541: usize = 2; +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_544], 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]; @@ -47171,14 +46768,14 @@ fn aiur_fn_544( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47191,19 +46788,19 @@ fn aiur_fn_544( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_544] = [__v_10]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_10]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47218,15 +46815,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 3; -const IN_545: usize = 3; -const OUT_545: usize = 2; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_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_545], 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]; @@ -47234,11 +46831,11 @@ fn aiur_fn_545( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47252,26 +46849,26 @@ fn aiur_fn_545( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_546: usize = 9; -const IN_546: usize = 9; -const OUT_546: usize = 2; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_543: usize = 9; +const IN_543: usize = 9; +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_546], 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]; @@ -47286,21 +46883,21 @@ fn aiur_fn_546( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47308,29 +46905,29 @@ fn aiur_fn_546( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47338,43 +46935,43 @@ fn aiur_fn_546( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47382,49 +46979,49 @@ fn aiur_fn_546( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47432,57 +47029,57 @@ fn aiur_fn_546( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47490,65 +47087,65 @@ fn aiur_fn_546( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47556,79 +47153,79 @@ fn aiur_fn_546( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47636,29 +47233,29 @@ fn aiur_fn_546( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47666,33 +47263,33 @@ fn aiur_fn_546( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47704,15 +47301,15 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 7; -const IN_547: usize = 7; -const OUT_547: usize = 2; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_544: usize = 7; +const IN_544: usize = 7; +const OUT_544: usize = 2; +fn aiur_fn_544( + inp: [G; IN_544], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], 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]; @@ -47725,19 +47322,19 @@ fn aiur_fn_547( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47746,15 +47343,15 @@ fn aiur_fn_547( }) } -const INPUT_SIZE_548: usize = 3; -const IN_548: usize = 3; -const OUT_548: usize = 2; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_545: usize = 3; +const IN_545: usize = 3; +const OUT_545: usize = 2; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], 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]; @@ -47775,19 +47372,19 @@ fn aiur_fn_548( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47801,25 +47398,25 @@ fn aiur_fn_548( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47834,15 +47431,15 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 12; -const IN_549: usize = 12; -const OUT_549: usize = 1; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_546: usize = 12; +const IN_546: usize = 12; +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_549], 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]; @@ -47859,50 +47456,50 @@ fn aiur_fn_549( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_549] = [__v_12]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47912,15 +47509,15 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 25; -const IN_550: usize = 25; -const OUT_550: usize = 2; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_547: usize = 25; +const IN_547: usize = 25; +const OUT_547: usize = 2; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_550], 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]; @@ -47947,42 +47544,42 @@ fn aiur_fn_550( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_551: usize = 25; -const IN_551: usize = 25; -const OUT_551: usize = 2; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_548: usize = 25; +const IN_548: usize = 25; +const OUT_548: usize = 2; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_551], 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]; @@ -48013,33 +47610,33 @@ fn aiur_fn_551( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_34, __v_35]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_34, __v_35]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48047,75 +47644,75 @@ fn aiur_fn_551( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_51, __v_52]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_51, __v_52]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_46, __v_47]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_46, __v_47]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48123,98 +47720,98 @@ fn aiur_fn_551( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_59, __v_60]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_59, __v_60]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_552: usize = 7; -const IN_552: usize = 7; -const OUT_552: usize = 2; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_549: usize = 7; +const IN_549: usize = 7; +const OUT_549: usize = 2; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], 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]; @@ -48226,15 +47823,15 @@ fn aiur_fn_552( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -48249,7 +47846,7 @@ fn aiur_fn_552( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -48264,34 +47861,34 @@ fn aiur_fn_552( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_40, __v_41]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_40, __v_41]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 25; -const IN_553: usize = 25; -const OUT_553: usize = 2; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_550: usize = 25; +const IN_550: usize = 25; +const OUT_550: usize = 2; +fn aiur_fn_550( + inp: [G; IN_550], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], 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]; @@ -48322,94 +47919,94 @@ fn aiur_fn_553( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 3; -const IN_554: usize = 3; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_551: usize = 3; +const IN_551: usize = 3; +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_554], ExecError> { +) -> Result<[G; OUT_551], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -48418,7 +48015,7 @@ fn aiur_fn_554( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -48442,29 +48039,29 @@ fn aiur_fn_554( let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_34]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_34]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_555: usize = 2; -const IN_555: usize = 2; -const OUT_555: usize = 12; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_552: usize = 2; +const IN_552: usize = 2; +const OUT_552: usize = 12; +fn aiur_fn_552( + inp: [G; IN_552], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], ExecError> { +) -> Result<[G; OUT_552], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -48479,25 +48076,25 @@ fn aiur_fn_555( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_555] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_556: usize = 2; -const IN_556: usize = 2; -const OUT_556: usize = 1; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_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_556], ExecError> { +) -> Result<[G; OUT_553], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -48512,53 +48109,53 @@ fn aiur_fn_556( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_556] = [__v_7]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_7]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_556] = [__v_14]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_14]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_557: usize = 3; -const IN_557: usize = 3; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_554: usize = 3; +const IN_554: usize = 3; +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_557], ExecError> { +) -> Result<[G; OUT_554], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_557] = [__v_5]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_5]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_558: usize = 5; -const IN_558: usize = 5; -const OUT_558: usize = 1; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_555: usize = 5; +const IN_555: usize = 5; +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_558], 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]; @@ -48574,23 +48171,23 @@ fn aiur_fn_558( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_558] = [__v_10]; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_10]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_558] = [__v_14]; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_14]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48600,15 +48197,15 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 5; -const IN_559: usize = 5; -const OUT_559: usize = 2; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_556: usize = 5; +const IN_556: usize = 5; +const OUT_556: usize = 2; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], 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]; @@ -48625,35 +48222,35 @@ fn aiur_fn_559( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_559] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_559] = [__v_16, __v_9]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_16, __v_9]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48665,15 +48262,15 @@ fn aiur_fn_559( }) } -const INPUT_SIZE_560: usize = 5; -const IN_560: usize = 5; -const OUT_560: usize = 1; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_557: usize = 5; +const IN_557: usize = 5; +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_560], 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]; @@ -48686,37 +48283,37 @@ fn aiur_fn_560( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_8]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { 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_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_560] = [__v_12]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_12]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_561: usize = 3; -const IN_561: usize = 3; -const OUT_561: usize = 1; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_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_561], 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]; @@ -48727,26 +48324,26 @@ fn aiur_fn_561( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_561] = [__v_11]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_558] = [__v_11]; + if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_562: usize = 4; -const IN_562: usize = 4; -const OUT_562: usize = 1; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_559: usize = 4; +const IN_559: usize = 4; +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_562], 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]; @@ -48754,33 +48351,33 @@ fn aiur_fn_562( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_562] = [__v_0]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_0]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_562] = [__v_0]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_0]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_562] = [__v_11]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_11]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48789,15 +48386,15 @@ fn aiur_fn_562( }) } -const INPUT_SIZE_563: usize = 3; -const IN_563: usize = 3; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_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_563], 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]; @@ -48811,19 +48408,19 @@ fn aiur_fn_563( 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_563] = [__v_8]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_8]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_8]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_8]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48833,28 +48430,28 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 3; -const IN_564: usize = 3; -const OUT_564: usize = 1; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_561: usize = 3; +const IN_561: usize = 3; +const OUT_561: usize = 1; +fn aiur_fn_561( + inp: [G; IN_561], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], ExecError> { +) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_564] = [__v_6]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_6]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -48863,32 +48460,32 @@ fn aiur_fn_564( 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_564] = [__v_8]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_8]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_564] = [__v_5]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_5]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_565: usize = 3; -const IN_565: usize = 3; -const OUT_565: usize = 1; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_562: usize = 3; +const IN_562: usize = 3; +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_565], 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]; @@ -48902,17 +48499,17 @@ fn aiur_fn_565( 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_565] = [__v_8]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_8]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_565] = [__v_7]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_7]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48922,15 +48519,15 @@ fn aiur_fn_565( }) } -const INPUT_SIZE_566: usize = 4; -const IN_566: usize = 4; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_563: usize = 4; +const IN_563: usize = 4; +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_566], 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]; @@ -48947,12 +48544,12 @@ fn aiur_fn_566( 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_566] = [__v_11]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_11]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -48965,7 +48562,7 @@ fn aiur_fn_566( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -48978,24 +48575,24 @@ fn aiur_fn_566( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __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_566] = [__v_34]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_34]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __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_566] = [__v_35]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_35]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49007,15 +48604,15 @@ fn aiur_fn_566( }) } -const INPUT_SIZE_567: usize = 3; -const IN_567: usize = 3; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_564: usize = 3; +const IN_564: usize = 3; +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_567], 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]; @@ -49029,8 +48626,8 @@ fn aiur_fn_567( 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_567] = [__v_8]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_8]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -49039,10 +48636,10 @@ fn aiur_fn_567( 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_568] = { let __args: [G; IN_568] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_11]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_11]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49052,15 +48649,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 5; -const IN_568: usize = 5; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_565: usize = 5; +const IN_565: usize = 5; +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_568], 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]; @@ -49078,12 +48675,12 @@ fn aiur_fn_568( 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_568] = [__v_12]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_12]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -49096,7 +48693,7 @@ fn aiur_fn_568( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -49109,17 +48706,17 @@ fn aiur_fn_568( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_35]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_35]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49129,11 +48726,11 @@ fn aiur_fn_568( 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_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_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_568] = [__v_41]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_41]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49145,15 +48742,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_566: usize = 2; +const IN_566: usize = 2; +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_569], 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]; @@ -49170,14 +48767,14 @@ fn aiur_fn_569( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_569] = [__v_8]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_8]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49190,25 +48787,25 @@ fn aiur_fn_569( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_8]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_9]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_9]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_9]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_9]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49225,15 +48822,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 1; -const IN_570: usize = 1; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_567: usize = 1; +const IN_567: usize = 1; +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_570], ExecError> { +) -> Result<[G; OUT_567], 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 }; @@ -49245,17 +48842,17 @@ fn aiur_fn_570( 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_570] = [__v_6]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_6]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_5]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_5]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49265,15 +48862,15 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 1; -const IN_571: usize = 1; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_568: usize = 1; +const IN_568: usize = 1; +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_571], ExecError> { +) -> Result<[G; OUT_568], 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 }; @@ -49283,25 +48880,25 @@ fn aiur_fn_571( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_571] = [__v_4]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_4]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_5]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_5]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_5]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_5]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49313,15 +48910,15 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 2; -const IN_572: usize = 2; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_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_572], 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]; @@ -49378,26 +48975,26 @@ fn aiur_fn_572( let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_572] = [__v_51]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_51]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_572] = [__v_53]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_53]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_572] = [__v_51]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_51]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49409,15 +49006,15 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_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_573], 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]; @@ -49472,8 +49069,8 @@ fn aiur_fn_573( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_49]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_49]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -49499,15 +49096,15 @@ fn aiur_fn_573( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_50]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_50]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_50]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_50]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49519,18 +49116,18 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 1; -const IN_574: usize = 1; -const OUT_574: usize = 0; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_571: usize = 1; +const IN_571: usize = 1; +const OUT_571: usize = 0; +fn aiur_fn_571( + inp: [G; IN_571], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], ExecError> { +) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -49584,31 +49181,31 @@ fn aiur_fn_574( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); @@ -49616,34 +49213,34 @@ fn aiur_fn_574( let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49652,15 +49249,15 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 12; -const IN_575: usize = 12; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_572: usize = 12; +const IN_572: usize = 12; +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_575], 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]; @@ -49676,56 +49273,56 @@ fn aiur_fn_575( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_575] = [__v_3]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_3]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_575] = [__v_12]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_575] = [__v_4]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_4]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_575] = [__v_6]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_6]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_575] = [__v_8]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_8]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_575] = [__v_9]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_9]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49735,15 +49332,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 1; -const IN_576: usize = 1; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_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_576], ExecError> { +) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -49754,18 +49351,18 @@ fn aiur_fn_576( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -49781,67 +49378,67 @@ fn aiur_fn_576( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_576] = [__v_20]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_20]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); - let __ret: [G; OUT_576] = [__v_9]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_9]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_576] = [__v_5]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49851,48 +49448,48 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 2; -const IN_577: usize = 2; -const OUT_577: usize = 0; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_574: usize = 2; +const IN_574: usize = 2; +const OUT_574: usize = 0; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_578: usize = 2; -const IN_578: usize = 2; -const OUT_578: usize = 0; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_575: usize = 2; +const IN_575: usize = 2; +const OUT_575: usize = 0; +fn aiur_fn_575( + inp: [G; IN_575], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], 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]; @@ -49902,28 +49499,28 @@ fn aiur_fn_578( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -49932,8 +49529,8 @@ fn aiur_fn_578( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49943,15 +49540,15 @@ 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_576: usize = 2; +const IN_576: usize = 2; +const OUT_576: usize = 0; +fn aiur_fn_576( + inp: [G; IN_576], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], 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]; @@ -49961,15 +49558,15 @@ fn aiur_fn_579( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = []; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_576] = []; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49979,15 +49576,15 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 3; -const IN_580: usize = 3; -const OUT_580: usize = 0; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_577: usize = 3; +const IN_577: usize = 3; +const OUT_577: usize = 0; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], 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]; @@ -50004,18 +49601,18 @@ fn aiur_fn_580( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -50030,62 +49627,62 @@ fn aiur_fn_580( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50095,113 +49692,64 @@ fn aiur_fn_580( }) } -const INPUT_SIZE_581: usize = 0; -const IN_581: usize = 0; -const OUT_581: usize = 1; -fn aiur_fn_581( - inp: [G; IN_581], - 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 = G::from_u64(231); - let __v_1: G = G::from_u64(117); - let __v_2: G = G::from_u64(170); - let __v_3: G = G::from_u64(49); - let __v_4: G = G::from_u64(117); - let __v_5: G = G::from_u64(154); - let __v_6: G = G::from_u64(157); - let __v_7: G = G::from_u64(74); - let __v_8: G = G::from_u64(205); - let __v_9: G = G::from_u64(188); - let __v_10: G = G::from_u64(43); - let __v_11: G = G::from_u64(133); - let __v_12: G = G::from_u64(25); - let __v_13: G = G::from_u64(255); - let __v_14: G = G::from_u64(115); - let __v_15: G = G::from_u64(245); - let __v_16: G = G::from_u64(117); - let __v_17: G = G::from_u64(82); - let __v_18: G = G::from_u64(187); - let __v_19: G = G::from_u64(12); - let __v_20: G = G::from_u64(186); - let __v_21: G = G::from_u64(77); - let __v_22: G = G::from_u64(175); - let __v_23: G = G::from_u64(22); - let __v_24: G = G::from_u64(89); - let __v_25: G = G::from_u64(187); - let __v_26: G = G::from_u64(160); - let __v_27: G = G::from_u64(15); - let __v_28: G = G::from_u64(106); - let __v_29: G = G::from_u64(147); - let __v_30: G = G::from_u64(27); - let __v_31: G = G::from_u64(75); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32]; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_582: usize = 0; -const IN_582: usize = 0; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_578: usize = 0; +const IN_578: usize = 0; +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_582], ExecError> { +) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(178); - let __v_1: G = G::from_u64(14); - let __v_2: G = G::from_u64(161); - let __v_3: G = G::from_u64(123); - let __v_4: G = G::from_u64(163); - let __v_5: G = G::from_u64(217); - let __v_6: G = G::from_u64(114); - let __v_7: G = G::from_u64(63); - let __v_8: G = G::from_u64(11); - let __v_9: G = G::from_u64(208); - let __v_10: G = G::from_u64(100); - let __v_11: G = G::from_u64(87); - let __v_12: G = G::from_u64(217); - let __v_13: G = G::from_u64(207); - let __v_14: G = G::from_u64(72); - let __v_15: G = G::from_u64(206); - let __v_16: G = G::from_u64(38); - let __v_17: G = G::from_u64(202); - let __v_18: G = G::from_u64(54); - let __v_19: G = G::from_u64(97); - let __v_20: G = G::from_u64(155); - let __v_21: G = G::from_u64(148); - let __v_22: G = G::from_u64(105); - let __v_23: G = G::from_u64(128); - let __v_24: G = G::from_u64(98); - let __v_25: G = G::from_u64(125); - let __v_26: G = G::from_u64(233); - let __v_27: G = G::from_u64(35); - let __v_28: G = G::from_u64(135); - let __v_29: G = G::from_u64(62); - let __v_30: G = G::from_u64(149); - let __v_31: G = G::from_u64(149); + let __v_0: G = G::from_u64(171); + let __v_1: G = G::from_u64(104); + let __v_2: G = G::from_u64(44); + let __v_3: G = G::from_u64(23); + let __v_4: G = G::from_u64(120); + let __v_5: G = G::from_u64(161); + let __v_6: G = G::from_u64(123); + let __v_7: G = G::from_u64(190); + let __v_8: G = G::from_u64(174); + let __v_9: G = G::from_u64(64); + let __v_10: G = G::from_u64(50); + let __v_11: G = G::from_u64(151); + let __v_12: G = G::from_u64(77); + let __v_13: G = G::from_u64(243); + let __v_14: G = G::from_u64(100); + let __v_15: G = G::from_u64(71); + let __v_16: G = G::from_u64(206); + let __v_17: G = G::from_u64(139); + let __v_18: G = G::from_u64(252); + let __v_19: G = G::from_u64(171); + let __v_20: G = G::from_u64(103); + let __v_21: G = G::from_u64(100); + let __v_22: G = G::from_u64(163); + let __v_23: G = G::from_u64(109); + let __v_24: G = G::from_u64(55); + let __v_25: G = G::from_u64(133); + let __v_26: G = G::from_u64(102); + let __v_27: G = G::from_u64(227); + let __v_28: G = G::from_u64(173); + let __v_29: G = G::from_u64(99); + let __v_30: G = G::from_u64(202); + let __v_31: G = G::from_u64(184); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_32]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = [__v_32]; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_583: usize = 3; -const IN_583: usize = 3; -const OUT_583: usize = 1; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_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_583], 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]; @@ -50210,8 +49758,8 @@ fn aiur_fn_583( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_583] = [__v_4]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_4]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50224,16 +49772,16 @@ fn aiur_fn_583( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_10]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_10]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_583] = [__v_8]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_8]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50242,67 +49790,98 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 0; -const IN_584: usize = 0; -const OUT_584: usize = 0; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_580: usize = 0; +const IN_580: usize = 0; +const OUT_580: usize = 0; +fn aiur_fn_580( + inp: [G; IN_580], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; - let __v_0: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - let __v_5: G = __loaded[3]; - let __v_6: G = __loaded[4]; - let __v_7: G = __loaded[5]; - let __v_8: G = __loaded[6]; - let __v_9: G = __loaded[7]; - let __v_10: G = __loaded[8]; - let __v_11: G = __loaded[9]; - let __v_12: G = __loaded[10]; - let __v_13: G = __loaded[11]; - match __v_2.as_canonical_u64() { + 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(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 __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + match __v_34.as_canonical_u64() { 5u64 => { - let __v_14: G = G::from_u64(1); - if (__v_3 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); + let __v_46: G = G::from_u64(1); + if (__v_35 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); } - let __v_15: G = G::from_u64(2); - if (__v_5 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); + let __v_47: G = G::from_u64(2); + if (__v_37 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); } - let __v_16: G = G::from_u64(1); - if (__v_7 != __v_16) { - return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); + let __v_48: G = G::from_u64(1); + if (__v_39 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }) } -const INPUT_SIZE_585: usize = 4; -const IN_585: usize = 4; -const OUT_585: usize = 0; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_581: usize = 4; +const IN_581: usize = 4; +const OUT_581: usize = 0; +fn aiur_fn_581( + inp: [G; IN_581], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], 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]; @@ -50310,9 +49889,9 @@ fn aiur_fn_585( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50323,9 +49902,9 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50336,10 +49915,10 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50350,9 +49929,9 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50373,34 +49952,34 @@ fn aiur_fn_585( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } - let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_586: usize = 2; -const IN_586: usize = 2; -const OUT_586: usize = 1; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_582: usize = 2; +const IN_582: usize = 2; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_586] = [__v_0]; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_582] = [__v_0]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50413,10 +49992,10 @@ fn aiur_fn_586( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_8]; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_582] = [__v_8]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50428,29 +50007,29 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 3; -const IN_587: usize = 3; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_583: usize = 3; +const IN_583: usize = 3; +const OUT_583: usize = 0; +fn aiur_fn_583( + inp: [G; IN_583], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], 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 __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = []; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50470,12 +50049,12 @@ fn aiur_fn_587( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = []; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50492,15 +50071,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 4; -const IN_588: usize = 4; -const OUT_588: usize = 0; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_584: usize = 4; +const IN_584: usize = 4; +const OUT_584: usize = 0; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], 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]; @@ -50509,8 +50088,8 @@ fn aiur_fn_588( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50529,7 +50108,7 @@ fn aiur_fn_588( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -50537,8 +50116,8 @@ fn aiur_fn_588( if (__v_9 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } - let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50555,20 +50134,20 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 3; -const IN_589: usize = 3; -const OUT_589: usize = 0; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_585: usize = 3; +const IN_585: usize = 3; +const OUT_585: usize = 0; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], 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 __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50585,7 +50164,7 @@ fn aiur_fn_589( let __v_15: G = __loaded[11]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { @@ -50594,8 +50173,8 @@ fn aiur_fn_589( if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } - let __ret: [G; OUT_589] = []; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_585] = []; + if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50605,15 +50184,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 7; -const IN_590: usize = 7; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_586: usize = 7; +const IN_586: usize = 7; +const OUT_586: usize = 0; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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]; @@ -50623,9 +50202,9 @@ fn aiur_fn_590( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -50635,32 +50214,32 @@ fn aiur_fn_590( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = []; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50670,15 +50249,15 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 4; -const IN_591: usize = 4; -const OUT_591: usize = 0; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_587: usize = 4; +const IN_587: usize = 4; +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_591], 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]; @@ -50686,8 +50265,8 @@ fn aiur_fn_591( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50705,7 +50284,7 @@ fn aiur_fn_591( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -50715,9 +50294,9 @@ fn aiur_fn_591( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50734,15 +50313,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 3; -const IN_592: usize = 3; -const OUT_592: usize = 0; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_588: usize = 3; +const IN_588: usize = 3; +const OUT_588: usize = 0; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], 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]; @@ -50750,27 +50329,27 @@ fn aiur_fn_592( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_593: usize = 3; -const IN_593: usize = 3; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_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_593], ExecError> { +) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -50781,8 +50360,8 @@ fn aiur_fn_593( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_593] = [__v_5]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = [__v_5]; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50802,10 +50381,10 @@ fn aiur_fn_593( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_12]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = [__v_12]; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50817,15 +50396,15 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 3; -const IN_594: usize = 3; -const OUT_594: usize = 0; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_590: usize = 3; +const IN_590: usize = 3; +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_594], 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]; @@ -50837,9 +50416,9 @@ fn aiur_fn_594( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -50847,29 +50426,29 @@ fn aiur_fn_594( } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_594] = []; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_594] = []; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_595: usize = 4; -const IN_595: usize = 4; -const OUT_595: usize = 0; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], 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]; @@ -50877,9 +50456,9 @@ fn aiur_fn_595( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50894,9 +50473,9 @@ fn aiur_fn_595( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50908,15 +50487,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 3; -const IN_596: usize = 3; -const OUT_596: usize = 0; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_592: usize = 3; +const IN_592: usize = 3; +const OUT_592: usize = 0; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], 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]; @@ -50927,52 +50506,52 @@ fn aiur_fn_596( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_596] = []; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_596] = []; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_597: usize = 2; -const IN_597: usize = 2; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_593: usize = 2; +const IN_593: usize = 2; +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_597], ExecError> { +) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_2]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_2]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_598: usize = 2; -const IN_598: usize = 2; -const OUT_598: usize = 1; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_594: usize = 2; +const IN_594: usize = 2; +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_598], 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]; @@ -50983,25 +50562,25 @@ fn aiur_fn_598( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_598] = [__v_5]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_5]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_598] = [__v_6]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_6]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_598] = [__v_6]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_6]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51013,19 +50592,19 @@ 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_595: usize = 2; +const IN_595: usize = 2; +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_599], ExecError> { +) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -51042,31 +50621,31 @@ fn aiur_fn_599( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_599] = [__v_15]; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_595] = [__v_15]; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_599] = [__v_15]; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_595] = [__v_15]; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_600: usize = 2; -const IN_600: usize = 2; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_596: usize = 2; +const IN_596: usize = 2; +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_600], 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]; @@ -51078,105 +50657,105 @@ fn aiur_fn_600( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_8]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_8]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_8]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_8]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51185,15 +50764,15 @@ fn aiur_fn_600( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51203,15 +50782,15 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 2; -const IN_601: usize = 2; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_597: usize = 2; +const IN_597: usize = 2; +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_601], 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]; @@ -51222,25 +50801,25 @@ fn aiur_fn_601( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_601] = [__v_5]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_5]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_601] = [__v_6]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_6]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_6]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_6]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51252,23 +50831,23 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 3; -const IN_602: usize = 3; -const OUT_602: usize = 2; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_598: usize = 3; +const IN_598: usize = 3; +const OUT_598: usize = 2; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], ExecError> { +) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51283,16 +50862,16 @@ fn aiur_fn_602( let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_602] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51301,15 +50880,15 @@ fn aiur_fn_602( }) } -const INPUT_SIZE_603: usize = 4; -const IN_603: usize = 4; -const OUT_603: usize = 0; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_599: usize = 4; +const IN_599: usize = 4; +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_603], 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]; @@ -51318,8 +50897,8 @@ fn aiur_fn_603( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = []; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51344,9 +50923,9 @@ fn aiur_fn_603( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_599] = []; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51363,22 +50942,22 @@ fn aiur_fn_603( }) } -const INPUT_SIZE_604: usize = 5; -const IN_604: usize = 5; -const OUT_604: usize = 0; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_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_604], ExecError> { +) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51396,25 +50975,25 @@ fn aiur_fn_604( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_604] = []; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = []; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51424,30 +51003,30 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 4; -const IN_605: usize = 4; -const OUT_605: usize = 0; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_601: usize = 4; +const IN_601: usize = 4; +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_605], ExecError> { +) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51458,19 +51037,19 @@ fn aiur_fn_605( 5u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -51480,28 +51059,28 @@ fn aiur_fn_605( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -51518,24 +51097,24 @@ fn aiur_fn_605( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51556,15 +51135,15 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 7; -const IN_606: usize = 7; -const OUT_606: usize = 0; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_602: usize = 7; +const IN_602: usize = 7; +const OUT_602: usize = 0; +fn aiur_fn_602( + inp: [G; IN_602], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], 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]; @@ -51576,12 +51155,12 @@ fn aiur_fn_606( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = []; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -51601,22 +51180,22 @@ fn aiur_fn_606( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_602] = []; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51628,15 +51207,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 4; -const IN_607: usize = 4; -const OUT_607: usize = 0; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_603: usize = 4; +const IN_603: usize = 4; +const OUT_603: usize = 0; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], 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]; @@ -51649,32 +51228,32 @@ fn aiur_fn_607( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 4; -const IN_608: usize = 4; -const OUT_608: usize = 0; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_604: usize = 4; +const IN_604: usize = 4; +const OUT_604: usize = 0; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51685,26 +51264,26 @@ fn aiur_fn_608( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_604] = []; + if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_609: usize = 8; -const IN_609: usize = 8; -const OUT_609: usize = 0; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_605: usize = 8; +const IN_605: usize = 8; +const OUT_605: usize = 0; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51718,25 +51297,25 @@ fn aiur_fn_609( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_610: usize = 10; -const IN_610: usize = 10; -const OUT_610: usize = 0; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_606: usize = 10; +const IN_606: usize = 10; +const OUT_606: usize = 0; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], 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]; @@ -51751,12 +51330,12 @@ fn aiur_fn_610( let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_610] = []; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -51773,15 +51352,15 @@ fn aiur_fn_610( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -51789,7 +51368,7 @@ fn aiur_fn_610( }, } }; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { @@ -51806,9 +51385,9 @@ fn aiur_fn_610( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_610] = []; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51820,15 +51399,15 @@ fn aiur_fn_610( }) } -const INPUT_SIZE_611: usize = 12; -const IN_611: usize = 12; -const OUT_611: usize = 0; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_607: usize = 12; +const IN_607: usize = 12; +const OUT_607: usize = 0; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51844,29 +51423,29 @@ fn aiur_fn_611( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_611] = []; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_611] = []; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_612: usize = 13; -const IN_612: usize = 13; -const OUT_612: usize = 0; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_608: usize = 13; +const IN_608: usize = 13; +const OUT_608: usize = 0; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], 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]; @@ -51883,16 +51462,16 @@ fn aiur_fn_612( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -51946,14 +51525,14 @@ fn aiur_fn_612( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51963,23 +51542,23 @@ fn aiur_fn_612( } }, _ => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_613: usize = 7; -const IN_613: usize = 7; -const OUT_613: usize = 0; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_609: usize = 7; +const IN_609: usize = 7; +const OUT_609: usize = 0; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], 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]; @@ -52038,8 +51617,8 @@ fn aiur_fn_613( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52051,13 +51630,13 @@ fn aiur_fn_613( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -52074,23 +51653,23 @@ fn aiur_fn_613( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -52098,17 +51677,17 @@ fn aiur_fn_613( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52118,9 +51697,9 @@ fn aiur_fn_613( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52132,15 +51711,15 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 16; -const IN_614: usize = 16; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_610: usize = 16; +const IN_610: usize = 16; +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_614], 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]; @@ -52158,37 +51737,37 @@ fn aiur_fn_614( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52197,26 +51776,26 @@ fn aiur_fn_614( match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_20]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_20]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52225,8 +51804,8 @@ fn aiur_fn_614( }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52237,15 +51816,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 4; -const IN_615: usize = 4; -const OUT_615: usize = 1; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_611: usize = 4; +const IN_611: usize = 4; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], 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]; @@ -52257,10 +51836,10 @@ fn aiur_fn_615( 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_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_8]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_8]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52275,16 +51854,16 @@ fn aiur_fn_615( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_12]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_12]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_8]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_8]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52293,15 +51872,15 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 5; -const IN_616: usize = 5; -const OUT_616: usize = 1; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_612: usize = 5; +const IN_612: usize = 5; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], 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]; @@ -52311,13 +51890,13 @@ fn aiur_fn_616( let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_8]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_8]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52328,13 +51907,13 @@ fn aiur_fn_616( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -52356,16 +51935,16 @@ fn aiur_fn_616( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_25]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_25]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_10]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_10]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52374,15 +51953,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 2; -const IN_617: usize = 2; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_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_617], 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]; @@ -52393,25 +51972,25 @@ fn aiur_fn_617( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_617] = [__v_5]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_5]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_6]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_6]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_6]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_6]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52423,15 +52002,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_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_618], 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]; @@ -52442,8 +52021,8 @@ fn aiur_fn_618( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_5]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_5]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52458,24 +52037,24 @@ fn aiur_fn_618( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_618] = [__v_10]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_10]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_10]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_10]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_9]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_9]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52487,15 +52066,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 13; -const IN_619: usize = 13; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_615: usize = 13; +const IN_615: usize = 13; +const OUT_615: usize = 1; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], 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]; @@ -52512,13 +52091,13 @@ fn aiur_fn_619( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_14]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_14]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52526,25 +52105,25 @@ fn aiur_fn_619( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_23]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -52562,22 +52141,22 @@ fn aiur_fn_619( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_619] = [__v_37]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_37]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_37]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_37]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_23]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52588,37 +52167,37 @@ fn aiur_fn_619( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_13]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_13]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_620: usize = 2; -const IN_620: usize = 2; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_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_620], ExecError> { +) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_620] = [__v_3]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_3]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52672,16 +52251,16 @@ fn aiur_fn_620( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_52]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_52]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_620] = [__v_51]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_51]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52692,18 +52271,18 @@ fn aiur_fn_620( }) } -const INPUT_SIZE_621: usize = 1; -const IN_621: usize = 1; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_617: usize = 1; +const IN_617: usize = 1; +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_621], ExecError> { +) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -52757,14 +52336,14 @@ fn aiur_fn_621( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_621] = [__v_49]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_49]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_621] = [__v_49]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_49]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52773,15 +52352,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 2; -const IN_622: usize = 2; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_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_622], 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]; @@ -52838,14 +52417,14 @@ fn aiur_fn_622( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52855,17 +52434,17 @@ fn aiur_fn_622( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_51]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_51]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52877,15 +52456,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 5; -const IN_623: usize = 5; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_619: usize = 5; +const IN_619: usize = 5; +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_623], 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]; @@ -52895,7 +52474,7 @@ fn aiur_fn_623( let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -52904,7 +52483,7 @@ fn aiur_fn_623( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52914,8 +52493,8 @@ fn aiur_fn_623( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_623] = [__v_16]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_16]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52930,15 +52509,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 12; -const IN_624: usize = 12; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_620: usize = 12; +const IN_620: usize = 12; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], 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]; @@ -52957,7 +52536,7 @@ fn aiur_fn_624( let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -52966,7 +52545,7 @@ fn aiur_fn_624( let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52976,16 +52555,16 @@ fn aiur_fn_624( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_624] = [__v_24]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_24]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_28]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_28]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52994,8 +52573,8 @@ fn aiur_fn_624( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_22]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_22]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53004,23 +52583,23 @@ fn aiur_fn_624( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_14]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_14]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_625: usize = 6; -const IN_625: usize = 6; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_621: usize = 6; +const IN_621: usize = 6; +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_625], 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]; @@ -53031,7 +52610,7 @@ fn aiur_fn_625( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -53040,17 +52619,17 @@ fn aiur_fn_625( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_625] = [__v_19]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_19]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53060,15 +52639,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 2; -const IN_626: usize = 2; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_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_626], 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]; @@ -53081,13 +52660,13 @@ fn aiur_fn_626( 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_626] = [__v_7]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_7]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -53095,13 +52674,13 @@ fn aiur_fn_626( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_12]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_12]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53111,15 +52690,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 3; -const IN_627: usize = 3; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_623: usize = 3; +const IN_623: usize = 3; +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_627], 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]; @@ -53130,8 +52709,8 @@ fn aiur_fn_627( 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_627] = [__v_6]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_6]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53142,30 +52721,30 @@ fn aiur_fn_627( 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_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __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_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_12]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 2; -const IN_628: usize = 2; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_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_628], ExecError> { +) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53219,14 +52798,14 @@ fn aiur_fn_628( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_51]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_51]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -53244,7 +52823,7 @@ fn aiur_fn_628( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); @@ -53255,16 +52834,16 @@ fn aiur_fn_628( let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_73]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_73]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_65]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_65]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53275,15 +52854,15 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 5; -const IN_629: usize = 5; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_625: usize = 5; +const IN_625: usize = 5; +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_629], 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]; @@ -53343,16 +52922,16 @@ fn aiur_fn_629( let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_54]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_54]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -53379,7 +52958,7 @@ fn aiur_fn_629( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -53388,20 +52967,20 @@ fn aiur_fn_629( let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_77]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_77]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_54]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_54]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53413,15 +52992,15 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 3; -const IN_630: usize = 3; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_626: usize = 3; +const IN_626: usize = 3; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], 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]; @@ -53436,49 +53015,49 @@ fn aiur_fn_630( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_630] = [__v_9]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_9]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_630] = [__v_11]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_11]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_11]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_11]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_10]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_10]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_9]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_9]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53490,15 +53069,15 @@ fn aiur_fn_630( }) } -const INPUT_SIZE_631: usize = 2; -const IN_631: usize = 2; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_627: usize = 2; +const IN_627: usize = 2; +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_631], 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]; @@ -53506,8 +53085,8 @@ fn aiur_fn_631( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_3]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_3]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53529,22 +53108,22 @@ fn aiur_fn_631( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53557,16 +53136,16 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53579,28 +53158,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53613,28 +53192,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53647,28 +53226,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53681,28 +53260,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53715,40 +53294,40 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53761,16 +53340,16 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53783,39 +53362,39 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53829,15 +53408,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 2; -const IN_632: usize = 2; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_628: usize = 2; +const IN_628: usize = 2; +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_632], 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]; @@ -53854,14 +53433,14 @@ fn aiur_fn_632( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53874,25 +53453,25 @@ fn aiur_fn_632( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_9]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_9]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_9]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_9]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53909,15 +53488,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_629: usize = 2; +const IN_629: usize = 2; +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_633], 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]; @@ -53934,14 +53513,14 @@ fn aiur_fn_633( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53954,25 +53533,25 @@ fn aiur_fn_633( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_9]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_9]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_9]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_9]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53989,15 +53568,15 @@ fn aiur_fn_633( }) } -const INPUT_SIZE_634: usize = 13; -const IN_634: usize = 13; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_630: usize = 13; +const IN_630: usize = 13; +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_634], 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]; @@ -54014,37 +53593,37 @@ fn aiur_fn_634( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_13]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_13]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_634] = [__v_15]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_15]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_635: usize = 2; -const IN_635: usize = 2; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_631: usize = 2; +const IN_631: usize = 2; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: [G; IN_631], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], ExecError> { +) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -54098,15 +53677,15 @@ fn aiur_fn_635( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_51]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_51]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_635] = [__v_1]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_1]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54115,15 +53694,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 5; -const IN_636: usize = 5; -const OUT_636: usize = 1; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_632: usize = 5; +const IN_632: usize = 5; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], 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]; @@ -54180,16 +53759,16 @@ fn aiur_fn_636( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -54206,9 +53785,9 @@ fn aiur_fn_636( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; @@ -54225,20 +53804,20 @@ fn aiur_fn_636( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_636] = [__v_75]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_75]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54246,10 +53825,10 @@ fn aiur_fn_636( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_636] = [__v_54]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_54]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54261,20 +53840,20 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 3; -const IN_637: usize = 3; -const OUT_637: usize = 1; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_633: usize = 3; +const IN_633: usize = 3; +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_637], ExecError> { +) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -54328,7 +53907,7 @@ fn aiur_fn_637( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -54340,7 +53919,7 @@ fn aiur_fn_637( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -54394,12 +53973,12 @@ fn aiur_fn_637( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; @@ -54417,7 +53996,7 @@ fn aiur_fn_637( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); @@ -54443,40 +54022,40 @@ fn aiur_fn_637( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_637] = [__v_100]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_100]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __ret: [G; OUT_637] = [__v_102]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_102]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_638: usize = 4; -const IN_638: usize = 4; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_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_638], ExecError> { +) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -54530,15 +54109,15 @@ fn aiur_fn_638( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_53]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_53]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_638] = [__v_3]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_3]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54547,15 +54126,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 7; -const IN_639: usize = 7; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_635: usize = 7; +const IN_635: usize = 7; +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_639], 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]; @@ -54614,16 +54193,16 @@ fn aiur_fn_639( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_639] = [__v_5]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_5]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; @@ -54640,9 +54219,9 @@ fn aiur_fn_639( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; @@ -54659,7 +54238,7 @@ fn aiur_fn_639( let __v_81: G = __loaded[11]; match __v_70.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; match __v_82.as_canonical_u64() { 1u64 => { @@ -54701,39 +54280,39 @@ fn aiur_fn_639( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_75]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_75]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { 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_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_78]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_78]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_80]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_80]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54743,10 +54322,10 @@ fn aiur_fn_639( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_56]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_56]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54758,15 +54337,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 3; -const IN_640: usize = 3; -const OUT_640: usize = 2; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 2; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], 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]; @@ -54782,28 +54361,28 @@ fn aiur_fn_640( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_640] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_640] = [__v_10, __v_2]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_10, __v_2]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54815,15 +54394,15 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 5; -const IN_641: usize = 5; -const OUT_641: usize = 2; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_637: usize = 5; +const IN_637: usize = 5; +const OUT_637: usize = 2; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], 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]; @@ -54841,12 +54420,12 @@ fn aiur_fn_641( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_2 - __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { @@ -54863,7 +54442,7 @@ fn aiur_fn_641( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -54879,18 +54458,18 @@ fn aiur_fn_641( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_641] = [__v_17, __v_4]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_17, __v_4]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54902,15 +54481,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 2; -const IN_642: usize = 2; -const OUT_642: usize = 4; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_638: usize = 2; +const IN_638: usize = 2; +const OUT_638: usize = 4; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], 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]; @@ -54963,27 +54542,27 @@ fn aiur_fn_642( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_642] = [__v_40, __v_41, __v_44, __v_47]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_40, __v_41, __v_44, __v_47]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __ret: [G; OUT_642] = [__v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54995,15 +54574,15 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 4; -const IN_643: usize = 4; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_639: usize = 4; +const IN_639: usize = 4; +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_643], 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]; @@ -55017,20 +54596,20 @@ fn aiur_fn_643( 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_643] = [__v_9]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_9]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_6]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_6]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55040,8 +54619,8 @@ fn aiur_fn_643( 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_643] = [__v_11]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_11]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55050,15 +54629,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 6; -const IN_644: usize = 6; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_640: usize = 6; +const IN_640: usize = 6; +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_644], 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]; @@ -55068,8 +54647,8 @@ fn aiur_fn_644( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_644] = [__v_0]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_0]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55080,19 +54659,19 @@ fn aiur_fn_644( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_17]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_17]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55104,15 +54683,15 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 2; -const IN_645: usize = 2; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_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_645], 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]; @@ -55121,8 +54700,8 @@ fn aiur_fn_645( 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_645] = [__v_4]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_4]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55136,18 +54715,18 @@ fn aiur_fn_645( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __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_645] = [__v_10]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_10]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -55159,19 +54738,19 @@ fn aiur_fn_645( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_18]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_18]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_16]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_16]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55182,15 +54761,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_642: usize = 4; +const IN_642: usize = 4; +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_646], 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]; @@ -55199,8 +54778,8 @@ fn aiur_fn_646( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_646] = [__v_0]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_0]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55216,25 +54795,25 @@ fn aiur_fn_646( 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_646] = { let __args: [G; IN_646] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_646] = [__v_17]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_17]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_647: usize = 3; -const IN_647: usize = 3; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_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_647], 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]; @@ -55245,21 +54824,21 @@ fn aiur_fn_647( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_647] = [__v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_0]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_647] = [__v_11]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_11]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55269,15 +54848,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_644: usize = 5; +const IN_644: usize = 5; +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_648], 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]; @@ -55287,32 +54866,32 @@ fn aiur_fn_648( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_6]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_6]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_5]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_5]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_649: usize = 3; -const IN_649: usize = 3; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_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_649], 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]; @@ -55320,8 +54899,8 @@ fn aiur_fn_649( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_649] = [__v_0]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_0]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55336,25 +54915,25 @@ fn aiur_fn_649( 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_649] = { let __args: [G; IN_649] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_15]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_15]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_650: usize = 2; -const IN_650: usize = 2; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_646: usize = 2; +const IN_646: usize = 2; +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_650], 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]; @@ -55364,18 +54943,18 @@ fn aiur_fn_650( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_650] = [__v_0]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_0]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __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_650] = [__v_8]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_8]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55385,15 +54964,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; -const OUT_651: usize = 2; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_647: usize = 2; +const IN_647: usize = 2; +const OUT_647: usize = 2; +fn aiur_fn_647( + inp: [G; IN_647], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], 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]; @@ -55402,8 +54981,8 @@ fn aiur_fn_651( 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_651] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55416,20 +54995,20 @@ fn aiur_fn_651( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -55440,21 +55019,21 @@ fn aiur_fn_651( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_19, __v_17]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_19, __v_17]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55465,15 +55044,15 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 3; -const IN_652: usize = 3; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_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_652], 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]; @@ -55487,21 +55066,21 @@ fn aiur_fn_652( 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_652] = [__v_8]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_8]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_11]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_11]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55511,15 +55090,15 @@ fn aiur_fn_652( }) } -const INPUT_SIZE_653: usize = 6; -const IN_653: usize = 6; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_649: usize = 6; +const IN_649: usize = 6; +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_653], 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]; @@ -55529,33 +55108,33 @@ fn aiur_fn_653( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_6]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_6]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_7]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_7]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_654: usize = 3; -const IN_654: usize = 3; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_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_654], 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]; @@ -55563,8 +55142,8 @@ fn aiur_fn_654( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_654] = [__v_0]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_0]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55577,25 +55156,25 @@ fn aiur_fn_654( 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_654] = { let __args: [G; IN_654] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_13]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_13]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_655: usize = 9; -const IN_655: usize = 9; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_651: usize = 9; +const IN_651: usize = 9; +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_655], 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]; @@ -55606,12 +55185,12 @@ fn aiur_fn_655( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); @@ -55619,12 +55198,12 @@ fn aiur_fn_655( let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -55632,7 +55211,7 @@ fn aiur_fn_655( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -55640,45 +55219,45 @@ fn aiur_fn_655( 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_650] = { let __args: [G; IN_650] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_25]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_25]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_656: usize = 3; -const IN_656: usize = 3; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; +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_656], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_4]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_4]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_657: usize = 4; -const IN_657: usize = 4; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_653: usize = 4; +const IN_653: usize = 4; +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_657], 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]; @@ -55687,8 +55266,8 @@ fn aiur_fn_657( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_657] = [__v_0]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_0]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55701,25 +55280,25 @@ fn aiur_fn_657( 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_657] = { let __args: [G; IN_657] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_14]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_14]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_658: usize = 2; -const IN_658: usize = 2; -const OUT_658: usize = 1; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_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_658], 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]; @@ -55729,18 +55308,18 @@ fn aiur_fn_658( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_658] = [__v_0]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_0]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __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_658] = [__v_8]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_8]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55750,15 +55329,15 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 9; -const IN_659: usize = 9; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_655: usize = 9; +const IN_655: usize = 9; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], 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]; @@ -55770,12 +55349,12 @@ fn aiur_fn_659( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55792,32 +55371,32 @@ fn aiur_fn_659( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_27]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_27]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 11; -const IN_660: usize = 11; -const OUT_660: usize = 1; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_656: usize = 11; +const IN_656: usize = 11; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], 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]; @@ -55830,28 +55409,28 @@ fn aiur_fn_660( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -55868,16 +55447,16 @@ fn aiur_fn_660( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); @@ -55891,13 +55470,13 @@ fn aiur_fn_660( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -55905,7 +55484,7 @@ fn aiur_fn_660( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -55917,7 +55496,7 @@ fn aiur_fn_660( let __v_64: G = G::from_u64(0); let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); @@ -55929,16 +55508,16 @@ fn aiur_fn_660( let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __ret: [G; OUT_660] = [__v_81]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_656] = [__v_81]; + if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55948,15 +55527,15 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 26; -const IN_661: usize = 26; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_657: usize = 26; +const IN_657: usize = 26; +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_661], 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]; @@ -55991,7 +55570,7 @@ fn aiur_fn_661( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -56042,11 +55621,11 @@ fn aiur_fn_661( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { @@ -56066,27 +55645,27 @@ fn aiur_fn_661( }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_54 - __v_55); let __v_57: G = (__v_53 * __v_56); let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, @@ -56100,26 +55679,26 @@ fn aiur_fn_661( }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56130,8 +55709,8 @@ fn aiur_fn_661( } }, _ => { - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56143,15 +55722,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 18; -const IN_662: usize = 18; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_658: usize = 18; +const IN_658: usize = 18; +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_662], 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]; @@ -56171,29 +55750,29 @@ fn aiur_fn_662( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { @@ -56206,22 +55785,22 @@ fn aiur_fn_662( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_662] = []; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_658] = []; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 3; -const IN_663: usize = 3; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_659: usize = 3; +const IN_659: usize = 3; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], 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]; @@ -56230,8 +55809,8 @@ fn aiur_fn_663( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_4]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_4]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56245,12 +55824,12 @@ fn aiur_fn_663( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_10]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_10]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -56278,11 +55857,11 @@ fn aiur_fn_663( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_663] = [__v_27]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56294,15 +55873,15 @@ fn aiur_fn_663( }) } -const INPUT_SIZE_664: usize = 15; -const IN_664: usize = 15; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_660: usize = 15; +const IN_660: usize = 15; +const OUT_660: usize = 1; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], 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]; @@ -56325,12 +55904,12 @@ fn aiur_fn_664( 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_664] = [__v_18]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_18]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -56348,24 +55927,24 @@ fn aiur_fn_664( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_35]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_35]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_31]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_31]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56374,15 +55953,15 @@ fn aiur_fn_664( }) } -const INPUT_SIZE_665: usize = 9; -const IN_665: usize = 9; -const OUT_665: usize = 0; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_661: usize = 9; +const IN_661: usize = 9; +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_665], 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]; @@ -56401,14 +55980,14 @@ fn aiur_fn_665( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56449,8 +56028,8 @@ fn aiur_fn_665( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -56461,7 +56040,7 @@ fn aiur_fn_665( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -56471,7 +56050,7 @@ fn aiur_fn_665( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -56479,9 +56058,9 @@ fn aiur_fn_665( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56498,15 +56077,15 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 12; -const IN_666: usize = 12; -const OUT_666: usize = 1; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_662: usize = 12; +const IN_662: usize = 12; +const OUT_662: usize = 1; +fn aiur_fn_662( + inp: [G; IN_662], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], 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]; @@ -56526,13 +56105,13 @@ fn aiur_fn_666( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_666] = [__v_0]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_662] = [__v_0]; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -56567,27 +56146,27 @@ fn aiur_fn_666( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); @@ -56596,32 +56175,32 @@ fn aiur_fn_666( let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56631,22 +56210,22 @@ fn aiur_fn_666( let __v_97: G = G::from_u64(0); let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_110]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_662] = [__v_110]; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56656,15 +56235,15 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 13; -const IN_667: usize = 13; -const OUT_667: usize = 1; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_663: usize = 13; +const IN_663: usize = 13; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], 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]; @@ -56679,19 +56258,19 @@ fn aiur_fn_667( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); @@ -56704,7 +56283,7 @@ fn aiur_fn_667( let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56718,26 +56297,26 @@ fn aiur_fn_667( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_667] = [__v_49]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_49]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_668: usize = 3; -const IN_668: usize = 3; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_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_668], 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]; @@ -56754,19 +56333,19 @@ fn aiur_fn_668( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_11]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_11]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_12]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_12]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56776,22 +56355,22 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 5; -const IN_669: usize = 5; -const OUT_669: usize = 1; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_665: usize = 5; +const IN_665: usize = 5; +const OUT_665: usize = 1; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -56845,15 +56424,15 @@ fn aiur_fn_669( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_669] = [__v_54]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = [__v_54]; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_669] = [__v_4]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = [__v_4]; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56862,15 +56441,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 8; -const IN_670: usize = 8; -const OUT_670: usize = 1; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_666: usize = 8; +const IN_666: usize = 8; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -56930,16 +56509,16 @@ fn aiur_fn_670( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_6]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_6]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -56956,9 +56535,9 @@ fn aiur_fn_670( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; @@ -56984,7 +56563,7 @@ fn aiur_fn_670( } }; let __v_83: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; match __v_84.as_canonical_u64() { 1u64 => { @@ -56994,9 +56573,9 @@ fn aiur_fn_670( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -57017,17 +56596,17 @@ fn aiur_fn_670( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_55]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_55]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_72]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_72]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57035,10 +56614,10 @@ fn aiur_fn_670( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_57]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_57]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57050,15 +56629,15 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 1; -const IN_671: usize = 1; -const OUT_671: usize = 1; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_667: usize = 1; +const IN_667: usize = 1; +const OUT_667: usize = 1; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], ExecError> { +) -> Result<[G; OUT_667], 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 }; @@ -57073,12 +56652,12 @@ fn aiur_fn_671( 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_671] = [__v_9]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_9]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -57105,11 +56684,11 @@ fn aiur_fn_671( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_671] = [__v_23]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_23]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57119,20 +56698,20 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 3; -const IN_672: usize = 3; -const OUT_672: usize = 1; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_668: usize = 3; +const IN_668: usize = 3; +const OUT_668: usize = 1; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -57141,7 +56720,7 @@ fn aiur_fn_672( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -57166,23 +56745,23 @@ fn aiur_fn_672( let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_672] = [__v_34]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_34]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_673: usize = 15; -const IN_673: usize = 15; -const OUT_673: usize = 1; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_669: usize = 15; +const IN_669: usize = 15; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], 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]; @@ -57205,12 +56784,12 @@ fn aiur_fn_673( 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_673] = [__v_18]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_18]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -57227,20 +56806,20 @@ fn aiur_fn_673( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_37]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_37]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57252,15 +56831,15 @@ fn aiur_fn_673( }) } -const INPUT_SIZE_674: usize = 5; -const IN_674: usize = 5; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_670: usize = 5; +const IN_670: usize = 5; +const OUT_670: usize = 1; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], 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]; @@ -57269,23 +56848,23 @@ fn aiur_fn_674( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_7]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_7]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_675: usize = 8; -const IN_675: usize = 8; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_671: usize = 8; +const IN_671: usize = 8; +const OUT_671: usize = 1; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], 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]; @@ -57307,12 +56886,12 @@ fn aiur_fn_675( 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_675] = [__v_16]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_16]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57330,28 +56909,28 @@ fn aiur_fn_675( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_34]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_34]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_29]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_29]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57363,15 +56942,15 @@ fn aiur_fn_675( }) } -const INPUT_SIZE_676: usize = 5; -const IN_676: usize = 5; -const OUT_676: usize = 1; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_672: usize = 5; +const IN_672: usize = 5; +const OUT_672: usize = 1; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], 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]; @@ -57386,23 +56965,23 @@ fn aiur_fn_676( let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_10]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_10]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_676] = [__v_9]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_9]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57412,8 +56991,8 @@ fn aiur_fn_676( let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_12]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_12]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57422,15 +57001,15 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 1; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_673: usize = 2; +const IN_673: usize = 2; +const OUT_673: usize = 1; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], 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]; @@ -57443,30 +57022,30 @@ fn aiur_fn_677( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_8]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_8]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_677] = [__v_1]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_1]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_678: usize = 7; -const IN_678: usize = 7; -const OUT_678: usize = 1; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_674: usize = 7; +const IN_674: usize = 7; +const OUT_674: usize = 1; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], 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]; @@ -57477,8 +57056,8 @@ fn aiur_fn_678( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_678] = [__v_0]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_0]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57489,26 +57068,26 @@ fn aiur_fn_678( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_18]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_18]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57517,19 +57096,19 @@ fn aiur_fn_678( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_26]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_26]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57543,15 +57122,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 13; -const IN_679: usize = 13; -const OUT_679: usize = 1; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_675: usize = 13; +const IN_675: usize = 13; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], 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]; @@ -57566,13 +57145,13 @@ fn aiur_fn_679( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -57584,24 +57163,24 @@ fn aiur_fn_679( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -57610,66 +57189,66 @@ fn aiur_fn_679( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_679] = [__v_62]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_62]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_680: usize = 1; -const IN_680: usize = 1; -const OUT_680: usize = 2; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_676: usize = 1; +const IN_676: usize = 1; +const OUT_676: usize = 2; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], ExecError> { +) -> Result<[G; OUT_676], 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_681] = { let __args: [G; IN_681] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_680] = [__v_6, __v_5]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_6, __v_5]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_681: usize = 2; -const IN_681: usize = 2; -const OUT_681: usize = 2; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +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_681], 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]; @@ -57682,31 +57261,31 @@ fn aiur_fn_681( 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_681] = { let __args: [G; IN_681] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_681] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_681] = [__v_1, __v_0]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_1, __v_0]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_682: usize = 8; -const IN_682: usize = 8; -const OUT_682: usize = 1; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_678: usize = 8; +const IN_678: usize = 8; +const OUT_678: usize = 1; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], 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]; @@ -57725,30 +57304,30 @@ fn aiur_fn_682( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_13]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_13]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -57762,37 +57341,37 @@ fn aiur_fn_682( let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_58]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_58]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57802,15 +57381,15 @@ fn aiur_fn_682( }) } -const INPUT_SIZE_683: usize = 3; -const IN_683: usize = 3; -const OUT_683: usize = 1; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_679: usize = 3; +const IN_679: usize = 3; +const OUT_679: usize = 1; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57824,19 +57403,19 @@ fn aiur_fn_683( 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_683] = [__v_8]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_8]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __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_683] = [__v_9]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_9]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57846,15 +57425,15 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 4; -const IN_684: usize = 4; -const OUT_684: usize = 1; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_680: usize = 4; +const IN_680: usize = 4; +const OUT_680: usize = 1; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57863,8 +57442,8 @@ fn aiur_fn_684( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_684] = [__v_0]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_0]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57879,25 +57458,25 @@ fn aiur_fn_684( 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_684] = { let __args: [G; IN_684] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_684] = [__v_16]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_16]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 6; -const IN_685: usize = 6; -const OUT_685: usize = 1; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_681: usize = 6; +const IN_681: usize = 6; +const OUT_681: usize = 1; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], 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,55 +57489,55 @@ fn aiur_fn_685( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_9]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_9]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_7]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_7]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_686: usize = 3; -const IN_686: usize = 3; -const OUT_686: usize = 2; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_682: usize = 3; +const IN_682: usize = 3; +const OUT_682: usize = 2; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_686] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_687: usize = 3; -const IN_687: usize = 3; -const OUT_687: usize = 2; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_683: usize = 3; +const IN_683: usize = 3; +const OUT_683: usize = 2; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57966,7 +57545,7 @@ fn aiur_fn_687( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -57975,15 +57554,15 @@ fn aiur_fn_687( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -57994,18 +57573,18 @@ fn aiur_fn_687( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_687] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58014,15 +57593,15 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 5; -const IN_688: usize = 5; -const OUT_688: usize = 2; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_684: usize = 5; +const IN_684: usize = 5; +const OUT_684: usize = 2; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], 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]; @@ -58040,12 +57619,12 @@ fn aiur_fn_688( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_688] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { @@ -58053,7 +57632,7 @@ fn aiur_fn_688( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -58064,18 +57643,18 @@ fn aiur_fn_688( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_688] = [__v_14, __v_4]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_14, __v_4]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_688] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58087,15 +57666,15 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 3; -const IN_689: usize = 3; -const OUT_689: usize = 1; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_685: usize = 3; +const IN_685: usize = 3; +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_689], 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]; @@ -58107,8 +57686,8 @@ fn aiur_fn_689( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_689] = [__v_6]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_6]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -58119,28 +57698,28 @@ fn aiur_fn_689( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_9]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_9]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_12]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_12]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_12]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_12]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58157,15 +57736,15 @@ fn aiur_fn_689( }) } -const INPUT_SIZE_690: usize = 7; -const IN_690: usize = 7; -const OUT_690: usize = 4; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_686: usize = 7; +const IN_686: usize = 7; +const OUT_686: usize = 4; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], 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]; @@ -58182,7 +57761,7 @@ fn aiur_fn_690( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); @@ -58195,53 +57774,53 @@ fn aiur_fn_690( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_690] = [__v_11, __v_12, __v_13, __v_0]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_11, __v_12, __v_13, __v_0]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_691: usize = 4; -const IN_691: usize = 4; -const OUT_691: usize = 1; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_687: usize = 4; +const IN_687: usize = 4; +const OUT_687: usize = 1; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], 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]; @@ -58259,12 +57838,12 @@ fn aiur_fn_691( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_12]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_12]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -58281,26 +57860,26 @@ fn aiur_fn_691( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_30]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_30]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_691] = [__v_23]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_23]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58312,15 +57891,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 13; -const IN_692: usize = 13; -const OUT_692: usize = 0; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_688: usize = 13; +const IN_688: usize = 13; +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_692], 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]; @@ -58337,9 +57916,9 @@ fn aiur_fn_692( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -58356,12 +57935,12 @@ fn aiur_fn_692( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); @@ -58371,11 +57950,11 @@ fn aiur_fn_692( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -58388,15 +57967,15 @@ fn aiur_fn_692( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -58404,9 +57983,9 @@ fn aiur_fn_692( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_692] = []; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58421,15 +58000,15 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 6; -const IN_693: usize = 6; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_689: usize = 6; +const IN_689: usize = 6; +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_693], 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]; @@ -58440,7 +58019,7 @@ fn aiur_fn_693( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -58449,16 +58028,16 @@ fn aiur_fn_693( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = []; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58468,15 +58047,15 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 2; -const IN_694: usize = 2; -const OUT_694: usize = 1; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_690: usize = 2; +const IN_690: usize = 2; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_694], 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]; @@ -58486,8 +58065,8 @@ fn aiur_fn_694( 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_694] = [__v_5]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_5]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58497,26 +58076,26 @@ fn aiur_fn_694( 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_694] = { let __args: [G; IN_694] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __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_694] = [__v_10]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_10]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_695: usize = 3; -const IN_695: usize = 3; -const OUT_695: usize = 0; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_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_695], 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]; @@ -58529,18 +58108,18 @@ fn aiur_fn_695( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_695] = []; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = []; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_695] = []; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_691] = []; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58552,15 +58131,15 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 4; -const IN_696: usize = 4; -const OUT_696: usize = 3; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_692: usize = 4; +const IN_692: usize = 4; +const OUT_692: usize = 3; +fn aiur_fn_692( + inp: [G; IN_692], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], 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]; @@ -58568,8 +58147,8 @@ fn aiur_fn_696( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58586,17 +58165,17 @@ fn aiur_fn_696( let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_696] = [__v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58605,15 +58184,15 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 13; -const IN_697: usize = 13; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_693: usize = 13; +const IN_693: usize = 13; +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_697], 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]; @@ -58628,58 +58207,58 @@ fn aiur_fn_697( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __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_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58688,71 +58267,71 @@ fn aiur_fn_697( let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __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_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -58769,15 +58348,15 @@ fn aiur_fn_697( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -58786,14 +58365,14 @@ fn aiur_fn_697( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58805,17 +58384,17 @@ fn aiur_fn_697( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58825,18 +58404,18 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 1; -const IN_698: usize = 1; -const OUT_698: usize = 0; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_694: usize = 1; +const IN_694: usize = 1; +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_698], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -58851,22 +58430,22 @@ fn aiur_fn_698( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_698] = []; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_694] = []; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 1; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_695: usize = 1; +const IN_695: usize = 1; +const OUT_695: usize = 1; +fn aiur_fn_695( + inp: [G; IN_695], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], ExecError> { +) -> Result<[G; OUT_695], 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 }; @@ -58891,96 +58470,96 @@ fn aiur_fn_699( match __v_1.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_24]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_24]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_22]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_22]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_23]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_23]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_700: usize = 1; -const IN_700: usize = 1; -const OUT_700: usize = 1; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_696: usize = 1; +const IN_696: usize = 1; +const OUT_696: usize = 1; +fn aiur_fn_696( + inp: [G; IN_696], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], ExecError> { +) -> Result<[G; OUT_696], 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 }; @@ -58992,19 +58571,19 @@ fn aiur_fn_700( 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_700] = [__v_6]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_6]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_6]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_6]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59014,15 +58593,15 @@ fn aiur_fn_700( }) } -const INPUT_SIZE_701: usize = 1; -const IN_701: usize = 1; -const OUT_701: usize = 1; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_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_701], ExecError> { +) -> Result<[G; OUT_697], 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 }; @@ -59042,21 +58621,21 @@ fn aiur_fn_701( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_701] = [__v_14]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = [__v_14]; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_701] = [__v_14]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = [__v_14]; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59068,15 +58647,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_698: usize = 1; +const IN_698: usize = 1; +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_702], ExecError> { +) -> Result<[G; OUT_698], 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 }; @@ -59121,21 +58700,21 @@ fn aiur_fn_702( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_702] = [__v_39]; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_698] = [__v_39]; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_702] = [__v_39]; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_698] = [__v_39]; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59147,15 +58726,15 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 1; -const IN_703: usize = 1; -const OUT_703: usize = 1; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_699: usize = 1; +const IN_699: usize = 1; +const OUT_699: usize = 1; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], ExecError> { +) -> Result<[G; OUT_699], 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 }; @@ -59211,8 +58790,8 @@ fn aiur_fn_703( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_703] = [__v_50]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_50]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -59220,18 +58799,18 @@ fn aiur_fn_703( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59239,18 +58818,18 @@ fn aiur_fn_703( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59258,18 +58837,18 @@ fn aiur_fn_703( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59286,15 +58865,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 48; -const IN_704: usize = 48; -const OUT_704: usize = 1; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_700: usize = 48; +const IN_700: usize = 48; +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_704], ExecError> { +) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59346,22 +58925,22 @@ fn aiur_fn_704( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_52]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59369,16 +58948,16 @@ fn aiur_fn_704( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_52]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59386,12 +58965,12 @@ fn aiur_fn_704( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59399,28 +58978,28 @@ fn aiur_fn_704( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_704] = [__v_48]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_48]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59429,15 +59008,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 2; -const IN_705: usize = 2; -const OUT_705: usize = 1; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_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_705], 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]; @@ -59448,8 +59027,8 @@ fn aiur_fn_705( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_705] = [__v_5]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_5]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -59457,15 +59036,15 @@ fn aiur_fn_705( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_705] = [__v_6]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_6]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_705] = [__v_6]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_6]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59477,18 +59056,18 @@ fn aiur_fn_705( }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_702: usize = 1; +const IN_702: usize = 1; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], 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_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -59542,14 +59121,14 @@ fn aiur_fn_706( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59557,8 +59136,8 @@ fn aiur_fn_706( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59566,8 +59145,8 @@ fn aiur_fn_706( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59575,39 +59154,39 @@ fn aiur_fn_706( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_707: usize = 3; -const IN_707: usize = 3; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_703: usize = 3; +const IN_703: usize = 3; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], 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]; @@ -59618,16 +59197,16 @@ fn aiur_fn_707( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_707] = []; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = []; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -59637,9 +59216,9 @@ fn aiur_fn_707( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59649,15 +59228,15 @@ fn aiur_fn_707( }) } -const INPUT_SIZE_708: usize = 4; -const IN_708: usize = 4; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_704: usize = 4; +const IN_704: usize = 4; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], 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]; @@ -59713,17 +59292,17 @@ fn aiur_fn_708( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_708] = []; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = []; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59733,15 +59312,15 @@ fn aiur_fn_708( }) } -const INPUT_SIZE_709: usize = 48; -const IN_709: usize = 48; -const OUT_709: usize = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_705: usize = 48; +const IN_705: usize = 48; +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_709], 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]; @@ -59791,9 +59370,9 @@ fn aiur_fn_709( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -59808,79 +59387,79 @@ fn aiur_fn_709( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_709] = []; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_710: usize = 1; -const IN_710: usize = 1; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_706: usize = 1; +const IN_706: usize = 1; +const OUT_706: usize = 1; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], ExecError> { +) -> Result<[G; OUT_706], 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_47] = { let __args: [G; IN_47] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_710] = [__v_8]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_706] = [__v_8]; + if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_711: usize = 2; -const IN_711: usize = 2; -const OUT_711: usize = 1; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_707: usize = 2; +const IN_707: usize = 2; +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_711], ExecError> { +) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_47] = { let __args: [G; IN_47] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_711] = [__v_10]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_707] = [__v_10]; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_712: usize = 1; -const IN_712: usize = 1; -const OUT_712: usize = 3; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_708: usize = 1; +const IN_708: usize = 1; +const OUT_708: usize = 3; +fn aiur_fn_708( + inp: [G; IN_708], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -59888,18 +59467,18 @@ fn aiur_fn_712( let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; let __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_712] = [__v_5, __v_10, __v_4]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_5, __v_10, __v_4]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -59939,25 +59518,25 @@ fn aiur_fn_712( 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_712] = [__v_35, __v_38, __v_2]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_35, __v_38, __v_2]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_712] = [__v_9, __v_10, __v_8]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_9, __v_10, __v_8]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59967,15 +59546,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 1; -const IN_713: usize = 1; -const OUT_713: usize = 1; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_709: usize = 1; +const IN_709: usize = 1; +const OUT_709: usize = 1; +fn aiur_fn_709( + inp: [G; IN_709], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_709], 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 }; @@ -60016,7 +59595,7 @@ fn aiur_fn_713( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; @@ -60029,7 +59608,7 @@ fn aiur_fn_713( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -60185,21 +59764,21 @@ fn aiur_fn_713( if (__v_82 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } - let __ret: [G; OUT_713] = [__v_49]; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_709] = [__v_49]; + if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_714: usize = 7; -const IN_714: usize = 7; -const OUT_714: usize = 6; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_710: usize = 7; +const IN_710: usize = 7; +const OUT_710: usize = 6; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], 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]; @@ -60214,28 +59793,28 @@ fn aiur_fn_714( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; - let __ret: [G; OUT_714] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60245,15 +59824,15 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 7; -const IN_715: usize = 7; -const OUT_715: usize = 1; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_711: usize = 7; +const IN_711: usize = 7; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], 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]; @@ -60263,23 +59842,23 @@ fn aiur_fn_715( 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_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_8]; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_711] = [__v_8]; + if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 14; -const IN_716: usize = 14; -const OUT_716: usize = 0; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_712: usize = 14; +const IN_712: usize = 14; +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_716], 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]; @@ -60295,18 +59874,18 @@ fn aiur_fn_716( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = []; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -60319,7 +59898,7 @@ fn aiur_fn_716( }, } }; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -60373,14 +59952,14 @@ fn aiur_fn_716( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60388,8 +59967,8 @@ fn aiur_fn_716( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60397,8 +59976,8 @@ fn aiur_fn_716( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60406,24 +59985,24 @@ fn aiur_fn_716( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_712] = []; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -60432,15 +60011,15 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 16; -const IN_717: usize = 16; -const OUT_717: usize = 0; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_713: usize = 16; +const IN_713: usize = 16; +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_717], 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]; @@ -60464,16 +60043,16 @@ fn aiur_fn_717( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_713] = []; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -60483,9 +60062,9 @@ fn aiur_fn_717( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_713] = []; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60495,15 +60074,15 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 13; -const IN_718: usize = 13; -const OUT_718: usize = 0; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_714: usize = 13; +const IN_714: usize = 13; +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_718], 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]; @@ -60524,16 +60103,16 @@ fn aiur_fn_718( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = []; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_714] = []; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60543,20 +60122,20 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 3; -const IN_719: usize = 3; -const OUT_719: usize = 0; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_715: usize = 3; +const IN_715: usize = 3; +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_719], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { @@ -60566,7 +60145,7 @@ fn aiur_fn_719( break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -60578,7 +60157,7 @@ fn aiur_fn_719( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -60587,29 +60166,29 @@ fn aiur_fn_719( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_719] = []; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_715] = []; + if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_720: usize = 1; -const IN_720: usize = 1; -const OUT_720: usize = 3; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 3; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -60619,17 +60198,17 @@ fn aiur_fn_720( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_720] = [__v_3, __v_4, __v_2]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = [__v_3, __v_4, __v_2]; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_720] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = [__v_5, __v_3, __v_4]; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60639,15 +60218,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 10; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_717: usize = 2; +const IN_717: usize = 2; +const OUT_717: usize = 10; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60655,8 +60234,8 @@ fn aiur_fn_721( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_721] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60671,23 +60250,23 @@ fn aiur_fn_721( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_721] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 3; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_718: usize = 2; +const IN_718: usize = 2; +const OUT_718: usize = 3; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], 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]; @@ -60695,32 +60274,32 @@ fn aiur_fn_722( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 3; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_719: usize = 2; +const IN_719: usize = 2; +const OUT_719: usize = 3; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60728,8 +60307,8 @@ fn aiur_fn_723( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60737,23 +60316,23 @@ fn aiur_fn_723( let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_719] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_724: usize = 2; -const IN_724: usize = 2; -const OUT_724: usize = 3; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_720: usize = 2; +const IN_720: usize = 2; +const OUT_720: usize = 3; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60761,8 +60340,8 @@ fn aiur_fn_724( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60773,22 +60352,22 @@ fn aiur_fn_724( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60800,15 +60379,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 2; -const IN_725: usize = 2; -const OUT_725: usize = 3; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_721: usize = 2; +const IN_721: usize = 2; +const OUT_721: usize = 3; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], 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]; @@ -60816,8 +60395,8 @@ fn aiur_fn_725( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60828,29 +60407,29 @@ fn aiur_fn_725( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60862,15 +60441,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 9; -const IN_726: usize = 9; -const OUT_726: usize = 2; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_722: usize = 9; +const IN_722: usize = 9; +const OUT_722: usize = 2; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], 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]; @@ -60881,19 +60460,19 @@ fn aiur_fn_726( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 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_726] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60912,7 +60491,7 @@ fn aiur_fn_726( let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -60921,28 +60500,28 @@ fn aiur_fn_726( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __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_726] = [__v_39, __v_37]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_39, __v_37]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 3; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_723: usize = 2; +const IN_723: usize = 2; +const OUT_723: usize = 3; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], 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]; @@ -60950,8 +60529,8 @@ fn aiur_fn_727( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60965,27 +60544,27 @@ fn aiur_fn_727( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 41; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_724: usize = 1; +const IN_724: usize = 1; +const OUT_724: usize = 41; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -61007,11 +60586,11 @@ fn aiur_fn_728( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -61022,7 +60601,7 @@ fn aiur_fn_728( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61033,7 +60612,7 @@ fn aiur_fn_728( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -61044,7 +60623,7 @@ fn aiur_fn_728( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -61055,25 +60634,25 @@ fn aiur_fn_728( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_728] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 49; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 49; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -61086,7 +60665,7 @@ fn aiur_fn_729( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61128,21 +60707,21 @@ fn aiur_fn_729( let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; - let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 9; -const IN_730: usize = 9; -const OUT_730: usize = 2; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_726: usize = 9; +const IN_726: usize = 9; +const OUT_726: usize = 2; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], 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]; @@ -61153,19 +60732,19 @@ fn aiur_fn_730( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 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_730] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61215,7 +60794,7 @@ fn aiur_fn_730( let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -61224,28 +60803,28 @@ fn aiur_fn_730( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __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_730] = [__v_70, __v_68]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_70, __v_68]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_731: usize = 2; -const IN_731: usize = 2; -const OUT_731: usize = 3; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 3; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], 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]; @@ -61253,8 +60832,8 @@ fn aiur_fn_731( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61268,27 +60847,27 @@ fn aiur_fn_731( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 55; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; +const OUT_728: usize = 55; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -61324,15 +60903,15 @@ fn aiur_fn_732( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61343,26 +60922,26 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61373,7 +60952,7 @@ fn aiur_fn_732( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -61384,7 +60963,7 @@ fn aiur_fn_732( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -61395,30 +60974,30 @@ fn aiur_fn_732( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61429,7 +61008,7 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61440,7 +61019,7 @@ fn aiur_fn_732( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61451,7 +61030,7 @@ fn aiur_fn_732( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61462,7 +61041,7 @@ fn aiur_fn_732( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61473,17 +61052,17 @@ fn aiur_fn_732( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); - let __ret: [G; OUT_732] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61493,15 +61072,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 63; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 63; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -61514,7 +61093,7 @@ fn aiur_fn_733( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61570,21 +61149,21 @@ fn aiur_fn_733( let __v_62: G = __r_arr[52]; let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; - let __ret: [G; OUT_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_734: usize = 9; -const IN_734: usize = 9; -const OUT_734: usize = 2; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_730: usize = 9; +const IN_730: usize = 9; +const OUT_730: usize = 2; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], 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]; @@ -61595,19 +61174,19 @@ fn aiur_fn_734( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 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_734] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61671,7 +61250,7 @@ fn aiur_fn_734( let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; @@ -61680,28 +61259,28 @@ fn aiur_fn_734( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __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_734] = [__v_84, __v_82]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_84, __v_82]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_735: usize = 1; -const IN_735: usize = 1; -const OUT_735: usize = 55; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_731: usize = 1; +const IN_731: usize = 1; +const OUT_731: usize = 55; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -61737,15 +61316,15 @@ fn aiur_fn_735( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61756,30 +61335,30 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61790,7 +61369,7 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61801,7 +61380,7 @@ fn aiur_fn_735( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61812,7 +61391,7 @@ fn aiur_fn_735( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61823,7 +61402,7 @@ fn aiur_fn_735( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61834,25 +61413,25 @@ fn aiur_fn_735( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); - let __ret: [G; OUT_735] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61863,22 +61442,22 @@ fn aiur_fn_735( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61889,18 +61468,18 @@ fn aiur_fn_735( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61911,7 +61490,7 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -61922,18 +61501,18 @@ fn aiur_fn_735( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61944,18 +61523,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61966,18 +61545,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61988,14 +61567,14 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -62017,7 +61596,7 @@ fn aiur_fn_735( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -62031,8 +61610,8 @@ fn aiur_fn_735( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = G::from_u64(8); let __v_31: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62042,15 +61621,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_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 1; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_732], 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 }; @@ -62075,44 +61654,44 @@ fn aiur_fn_736( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_736] = [__v_23]; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_23]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_737: usize = 1; -const IN_737: usize = 1; -const OUT_737: usize = 1; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_733], 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_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62122,35 +61701,35 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 3; -const IN_738: usize = 3; -const OUT_738: usize = 0; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_734: usize = 3; +const IN_734: usize = 3; +const OUT_734: usize = 0; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = []; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = []; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62160,35 +61739,35 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 3; -const IN_739: usize = 3; -const OUT_739: usize = 0; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_735: usize = 3; +const IN_735: usize = 3; +const OUT_735: usize = 0; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = []; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = []; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62198,35 +61777,35 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 3; -const IN_740: usize = 3; -const OUT_740: usize = 0; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_736: usize = 3; +const IN_736: usize = 3; +const OUT_736: usize = 0; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = []; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = []; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62236,31 +61815,31 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 3; -const IN_741: usize = 3; -const OUT_741: usize = 0; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_737: usize = 3; +const IN_737: usize = 3; +const OUT_737: usize = 0; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], 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 __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = []; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = []; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62270,15 +61849,15 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 17; -const IN_742: usize = 17; -const OUT_742: usize = 0; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_738: usize = 17; +const IN_738: usize = 17; +const OUT_738: usize = 0; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], 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]; @@ -62299,8 +61878,8 @@ fn aiur_fn_742( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62328,8 +61907,8 @@ fn aiur_fn_742( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62339,23 +61918,23 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 3; -const IN_743: usize = 3; -const OUT_743: usize = 0; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_739: usize = 3; +const IN_739: usize = 3; +const OUT_739: usize = 0; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], ExecError> { +) -> Result<[G; OUT_739], ExecError> { stacker::maybe_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_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62521,8 +62100,8 @@ fn aiur_fn_743( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } - let __ret: [G; OUT_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62532,27 +62111,27 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 3; -const IN_744: usize = 3; -const OUT_744: usize = 0; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_740: usize = 3; +const IN_740: usize = 3; +const OUT_740: usize = 0; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __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]; @@ -62716,8 +62295,8 @@ fn aiur_fn_744( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62727,15 +62306,15 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 10; -const IN_745: usize = 10; -const OUT_745: usize = 0; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_741: usize = 10; +const IN_741: usize = 10; +const OUT_741: usize = 0; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], 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]; @@ -62783,8 +62362,8 @@ fn aiur_fn_745( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62812,7 +62391,7 @@ fn aiur_fn_745( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -62861,7 +62440,7 @@ fn aiur_fn_745( if (__v_37 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -62870,9 +62449,9 @@ fn aiur_fn_745( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62891,23 +62470,23 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 3; -const IN_746: usize = 3; -const OUT_746: usize = 0; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_742: usize = 3; +const IN_742: usize = 3; +const OUT_742: usize = 0; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], ExecError> { +) -> Result<[G; OUT_742], ExecError> { stacker::maybe_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_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62919,9 +62498,9 @@ fn aiur_fn_746( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62931,15 +62510,15 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 49; -const IN_747: usize = 49; -const OUT_747: usize = 0; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_743: usize = 49; +const IN_743: usize = 49; +const OUT_743: usize = 0; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], 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]; @@ -62990,7 +62569,7 @@ fn aiur_fn_747( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -63029,14 +62608,14 @@ fn aiur_fn_747( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63045,15 +62624,15 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 2; -const IN_748: usize = 2; -const OUT_748: usize = 0; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_744: usize = 2; +const IN_744: usize = 2; +const OUT_744: usize = 0; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], 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]; @@ -63110,15 +62689,15 @@ fn aiur_fn_748( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63128,29 +62707,29 @@ fn aiur_fn_748( }) } -const INPUT_SIZE_749: usize = 3; -const IN_749: usize = 3; -const OUT_749: usize = 0; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_745: usize = 3; +const IN_745: usize = 3; +const OUT_745: usize = 0; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63160,15 +62739,15 @@ fn aiur_fn_749( }) } -const INPUT_SIZE_750: usize = 99; -const IN_750: usize = 99; -const OUT_750: usize = 0; -fn aiur_fn_750( - inp: [G; IN_750], +const INPUT_SIZE_746: usize = 99; +const IN_746: usize = 99; +const OUT_746: usize = 0; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_750], 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]; @@ -63275,13 +62854,13 @@ fn aiur_fn_750( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63296,14 +62875,14 @@ fn aiur_fn_750( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63318,17 +62897,17 @@ fn aiur_fn_750( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63345,15 +62924,15 @@ fn aiur_fn_750( }) } -const INPUT_SIZE_751: usize = 2; -const IN_751: usize = 2; -const OUT_751: usize = 0; -fn aiur_fn_751( - inp: [G; IN_751], +const INPUT_SIZE_747: usize = 2; +const IN_747: usize = 2; +const OUT_747: usize = 0; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_751], 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]; @@ -63424,12 +63003,12 @@ fn aiur_fn_751( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -63475,10 +63054,10 @@ fn aiur_fn_751( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { 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 __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63488,15 +63067,15 @@ fn aiur_fn_751( }) } -const INPUT_SIZE_752: usize = 55; -const IN_752: usize = 55; -const OUT_752: usize = 0; -fn aiur_fn_752( - inp: [G; IN_752], +const INPUT_SIZE_748: usize = 55; +const IN_748: usize = 55; +const OUT_748: usize = 0; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_752], 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]; @@ -63553,7 +63132,7 @@ fn aiur_fn_752( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -63610,13 +63189,13 @@ fn aiur_fn_752( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63631,17 +63210,17 @@ fn aiur_fn_752( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63656,11 +63235,11 @@ fn aiur_fn_752( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63675,11 +63254,11 @@ fn aiur_fn_752( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_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[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63694,11 +63273,11 @@ fn aiur_fn_752( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63713,10 +63292,10 @@ fn aiur_fn_752( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63731,10 +63310,10 @@ fn aiur_fn_752( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63749,10 +63328,10 @@ fn aiur_fn_752( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63765,9 +63344,9 @@ fn aiur_fn_752( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { 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 __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63784,41 +63363,41 @@ fn aiur_fn_752( }) } -const INPUT_SIZE_753: usize = 2; -const IN_753: usize = 2; -const OUT_753: usize = 0; -fn aiur_fn_753( - inp: [G; IN_753], +const INPUT_SIZE_749: usize = 2; +const IN_749: usize = 2; +const OUT_749: usize = 0; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_753], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } - let __ret: [G; OUT_753] = []; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_754: usize = 8; -const IN_754: usize = 8; -const OUT_754: usize = 0; -fn aiur_fn_754( - inp: [G; IN_754], +const INPUT_SIZE_750: usize = 8; +const IN_750: usize = 8; +const OUT_750: usize = 0; +fn aiur_fn_750( + inp: [G; IN_750], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_754], 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]; @@ -63833,7 +63412,7 @@ fn aiur_fn_754( let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(103); let __v_14: G = G::from_u64(230); @@ -63885,9 +63464,9 @@ fn aiur_fn_754( let __v_60: G = G::from_u64(1); let __v_61: G = G::from_u64(1); let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -64043,26 +63622,26 @@ fn aiur_fn_754( } match __v_97.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -64072,9 +63651,9 @@ fn aiur_fn_754( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64083,23 +63662,23 @@ fn aiur_fn_754( } }, 5u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -64155,21 +63734,21 @@ fn aiur_fn_754( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64179,15 +63758,15 @@ fn aiur_fn_754( }) } -const INPUT_SIZE_755: usize = 8; -const IN_755: usize = 8; -const OUT_755: usize = 0; -fn aiur_fn_755( - inp: [G; IN_755], +const INPUT_SIZE_751: usize = 8; +const IN_751: usize = 8; +const OUT_751: usize = 0; +fn aiur_fn_751( + inp: [G; IN_751], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_755], 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]; @@ -64197,27 +63776,27 @@ fn aiur_fn_755( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_755] = []; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_756: usize = 3; -const IN_756: usize = 3; -const OUT_756: usize = 1; -fn aiur_fn_756( - inp: [G; IN_756], +const INPUT_SIZE_752: usize = 3; +const IN_752: usize = 3; +const OUT_752: usize = 1; +fn aiur_fn_752( + inp: [G; IN_752], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_756], ExecError> { +) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -64225,13 +63804,13 @@ fn aiur_fn_756( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_756] = [__v_2]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_752] = [__v_2]; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_756] = [__v_5]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_752] = [__v_5]; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64241,15 +63820,15 @@ fn aiur_fn_756( }) } -const INPUT_SIZE_757: usize = 2; -const IN_757: usize = 2; -const OUT_757: usize = 1; -fn aiur_fn_757( - inp: [G; IN_757], +const INPUT_SIZE_753: usize = 2; +const IN_753: usize = 2; +const OUT_753: usize = 1; +fn aiur_fn_753( + inp: [G; IN_753], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_757], ExecError> { +) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64264,17 +63843,17 @@ fn aiur_fn_757( 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_757] = [__v_9]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = [__v_9]; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __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_757] = [__v_7]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = [__v_7]; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64284,15 +63863,15 @@ fn aiur_fn_757( }) } -const INPUT_SIZE_758: usize = 1; -const IN_758: usize = 1; -const OUT_758: usize = 8; -fn aiur_fn_758( - inp: [G; IN_758], +const INPUT_SIZE_754: usize = 1; +const IN_754: usize = 1; +const OUT_754: usize = 8; +fn aiur_fn_754( + inp: [G; IN_754], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_758], ExecError> { +) -> Result<[G; OUT_754], 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 }; @@ -64316,12 +63895,12 @@ fn aiur_fn_758( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_754] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -64330,7 +63909,7 @@ fn aiur_fn_758( let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -64339,8 +63918,8 @@ fn aiur_fn_758( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __ret: [G; OUT_758] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_754] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64350,15 +63929,15 @@ fn aiur_fn_758( }) } -const INPUT_SIZE_759: usize = 2; -const IN_759: usize = 2; -const OUT_759: usize = 1; -fn aiur_fn_759( - inp: [G; IN_759], +const INPUT_SIZE_755: usize = 2; +const IN_755: usize = 2; +const OUT_755: usize = 1; +fn aiur_fn_755( + inp: [G; IN_755], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_759], ExecError> { +) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64369,17 +63948,17 @@ fn aiur_fn_759( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_759] = [__v_1]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_755] = [__v_1]; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __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_759] = [__v_8]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_755] = [__v_8]; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64389,15 +63968,15 @@ fn aiur_fn_759( }) } -const INPUT_SIZE_760: usize = 1; -const IN_760: usize = 1; -const OUT_760: usize = 8; -fn aiur_fn_760( - inp: [G; IN_760], +const INPUT_SIZE_756: usize = 1; +const IN_756: usize = 1; +const OUT_756: usize = 8; +fn aiur_fn_756( + inp: [G; IN_756], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_760], ExecError> { +) -> Result<[G; OUT_756], 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 }; @@ -64414,12 +63993,12 @@ fn aiur_fn_760( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_760] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -64428,7 +64007,7 @@ fn aiur_fn_760( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64437,8 +64016,8 @@ fn aiur_fn_760( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __ret: [G; OUT_760] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64448,15 +64027,15 @@ fn aiur_fn_760( }) } -const INPUT_SIZE_761: usize = 8; -const IN_761: usize = 8; -const OUT_761: usize = 1; -fn aiur_fn_761( - inp: [G; IN_761], +const INPUT_SIZE_757: usize = 8; +const IN_757: usize = 8; +const OUT_757: usize = 1; +fn aiur_fn_757( + inp: [G; IN_757], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_761], ExecError> { +) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64468,8 +64047,8 @@ fn aiur_fn_761( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_761] = [__v_7]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_7]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64490,25 +64069,25 @@ fn aiur_fn_761( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_21]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_21]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_761] = [__v_4]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_4]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_22]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_22]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64522,37 +64101,37 @@ fn aiur_fn_761( }) } -const INPUT_SIZE_762: usize = 1; -const IN_762: usize = 1; -const OUT_762: usize = 1; -fn aiur_fn_762( - inp: [G; IN_762], +const INPUT_SIZE_758: usize = 1; +const IN_758: usize = 1; +const OUT_758: usize = 1; +fn aiur_fn_758( + inp: [G; IN_758], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_762], ExecError> { +) -> Result<[G; OUT_758], 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_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_762] = [__v_4]; - if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_4]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_763: usize = 2; -const IN_763: usize = 2; -const OUT_763: usize = 1; -fn aiur_fn_763( - inp: [G; IN_763], +const INPUT_SIZE_759: usize = 2; +const IN_759: usize = 2; +const OUT_759: usize = 1; +fn aiur_fn_759( + inp: [G; IN_759], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_763], ExecError> { +) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64562,17 +64141,17 @@ fn aiur_fn_763( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_763] = [__v_1]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_1]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __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_763] = [__v_7]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_7]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64582,15 +64161,15 @@ fn aiur_fn_763( }) } -const INPUT_SIZE_764: usize = 1; -const IN_764: usize = 1; -const OUT_764: usize = 1; -fn aiur_fn_764( - inp: [G; IN_764], +const INPUT_SIZE_760: usize = 1; +const IN_760: usize = 1; +const OUT_760: usize = 1; +fn aiur_fn_760( + inp: [G; IN_760], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_764], ExecError> { +) -> Result<[G; OUT_760], 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 }; @@ -64600,17 +64179,17 @@ fn aiur_fn_764( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_764] = [__v_4]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_4]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_764] = [__v_6]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_6]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64620,15 +64199,15 @@ fn aiur_fn_764( }) } -const INPUT_SIZE_765: usize = 1; -const IN_765: usize = 1; -const OUT_765: usize = 8; -fn aiur_fn_765( - inp: [G; IN_765], +const INPUT_SIZE_761: usize = 1; +const IN_761: usize = 1; +const OUT_761: usize = 8; +fn aiur_fn_761( + inp: [G; IN_761], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_765], ExecError> { +) -> Result<[G; OUT_761], 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 }; @@ -64678,12 +64257,12 @@ fn aiur_fn_765( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __ret: [G; OUT_765] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -64692,7 +64271,7 @@ fn aiur_fn_765( let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -64701,8 +64280,8 @@ fn aiur_fn_765( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __ret: [G; OUT_765] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64712,19 +64291,19 @@ fn aiur_fn_765( }) } -const INPUT_SIZE_766: usize = 2; -const IN_766: usize = 2; -const OUT_766: usize = 1; -fn aiur_fn_766( - inp: [G; IN_766], +const INPUT_SIZE_762: usize = 2; +const IN_762: usize = 2; +const OUT_762: usize = 1; +fn aiur_fn_762( + inp: [G; IN_762], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_766], ExecError> { +) -> Result<[G; OUT_762], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __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]; @@ -64732,8 +64311,8 @@ fn aiur_fn_766( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_766] = [__v_4]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_762] = [__v_4]; + if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64743,15 +64322,15 @@ fn aiur_fn_766( }) } -const INPUT_SIZE_767: usize = 1; -const IN_767: usize = 1; -const OUT_767: usize = 1; -fn aiur_fn_767( - inp: [G; IN_767], +const INPUT_SIZE_763: usize = 1; +const IN_763: usize = 1; +const OUT_763: usize = 1; +fn aiur_fn_763( + inp: [G; IN_763], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_767], ExecError> { +) -> Result<[G; OUT_763], 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 }; @@ -64768,17 +64347,17 @@ fn aiur_fn_767( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_767] = [__v_11]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_11]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_767] = [__v_13]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_13]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64788,15 +64367,15 @@ fn aiur_fn_767( }) } -const INPUT_SIZE_768: usize = 9; -const IN_768: usize = 9; -const OUT_768: usize = 45; -fn aiur_fn_768( - inp: [G; IN_768], +const INPUT_SIZE_764: usize = 9; +const IN_764: usize = 9; +const OUT_764: usize = 45; +fn aiur_fn_764( + inp: [G; IN_764], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_768], ExecError> { +) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64857,16 +64436,16 @@ fn aiur_fn_768( let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_768] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -64875,7 +64454,7 @@ fn aiur_fn_768( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -64921,8 +64500,8 @@ fn aiur_fn_768( let __v_107: G = __r_arr[42]; let __v_108: G = __r_arr[43]; let __v_109: G = __r_arr[44]; - let __ret: [G; OUT_768] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64937,15 +64516,15 @@ fn aiur_fn_768( }) } -const INPUT_SIZE_769: usize = 1; -const IN_769: usize = 1; -const OUT_769: usize = 8; -fn aiur_fn_769( - inp: [G; IN_769], +const INPUT_SIZE_765: usize = 1; +const IN_765: usize = 1; +const OUT_765: usize = 8; +fn aiur_fn_765( + inp: [G; IN_765], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_769], ExecError> { +) -> Result<[G; OUT_765], 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 }; @@ -65006,12 +64585,12 @@ fn aiur_fn_769( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __ret: [G; OUT_769] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -65020,7 +64599,7 @@ fn aiur_fn_769( let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -65029,8 +64608,8 @@ fn aiur_fn_769( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __ret: [G; OUT_769] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65040,15 +64619,15 @@ fn aiur_fn_769( }) } -const INPUT_SIZE_770: usize = 1; -const IN_770: usize = 1; -const OUT_770: usize = 8; -fn aiur_fn_770( - inp: [G; IN_770], +const INPUT_SIZE_766: usize = 1; +const IN_766: usize = 1; +const OUT_766: usize = 8; +fn aiur_fn_766( + inp: [G; IN_766], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_770], ExecError> { +) -> Result<[G; OUT_766], 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 }; @@ -65073,12 +64652,12 @@ fn aiur_fn_770( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_770] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -65087,7 +64666,7 @@ fn aiur_fn_770( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -65096,8 +64675,8 @@ fn aiur_fn_770( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __ret: [G; OUT_770] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65107,15 +64686,15 @@ fn aiur_fn_770( }) } -const INPUT_SIZE_771: usize = 9; -const IN_771: usize = 9; -const OUT_771: usize = 34; -fn aiur_fn_771( - inp: [G; IN_771], +const INPUT_SIZE_767: usize = 9; +const IN_767: usize = 9; +const OUT_767: usize = 34; +fn aiur_fn_767( + inp: [G; IN_767], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_771], ExecError> { +) -> Result<[G; OUT_767], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65165,16 +64744,16 @@ fn aiur_fn_771( let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -65183,7 +64762,7 @@ fn aiur_fn_771( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -65218,8 +64797,8 @@ fn aiur_fn_771( let __v_85: G = __r_arr[31]; let __v_86: G = __r_arr[32]; let __v_87: G = __r_arr[33]; - let __ret: [G; OUT_771] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65234,15 +64813,15 @@ fn aiur_fn_771( }) } -const INPUT_SIZE_772: usize = 1; -const IN_772: usize = 1; -const OUT_772: usize = 1; -fn aiur_fn_772( - inp: [G; IN_772], +const INPUT_SIZE_768: usize = 1; +const IN_768: usize = 1; +const OUT_768: usize = 1; +fn aiur_fn_768( + inp: [G; IN_768], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_772], ExecError> { +) -> Result<[G; OUT_768], 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 }; @@ -65252,14 +64831,14 @@ fn aiur_fn_772( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_772] = [__v_4]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_4]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_772] = [__v_4]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_4]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65269,15 +64848,15 @@ fn aiur_fn_772( }) } -const INPUT_SIZE_773: usize = 5; -const IN_773: usize = 5; -const OUT_773: usize = 1; -fn aiur_fn_773( - inp: [G; IN_773], +const INPUT_SIZE_769: usize = 5; +const IN_769: usize = 5; +const OUT_769: usize = 1; +fn aiur_fn_769( + inp: [G; IN_769], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_773], ExecError> { +) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65298,17 +64877,17 @@ fn aiur_fn_773( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_15]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_15]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_13]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_13]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65318,15 +64897,15 @@ fn aiur_fn_773( }) } -const INPUT_SIZE_774: usize = 2; -const IN_774: usize = 2; -const OUT_774: usize = 1; -fn aiur_fn_774( - inp: [G; IN_774], +const INPUT_SIZE_770: usize = 2; +const IN_770: usize = 2; +const OUT_770: usize = 1; +fn aiur_fn_770( + inp: [G; IN_770], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_774], ExecError> { +) -> Result<[G; OUT_770], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65335,8 +64914,8 @@ fn aiur_fn_774( 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_774] = [__v_4]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_4]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65349,11 +64928,11 @@ fn aiur_fn_774( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __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_774] = [__v_9]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_9]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65365,28 +64944,28 @@ fn aiur_fn_774( }) } -const INPUT_SIZE_775: usize = 2; -const IN_775: usize = 2; -const OUT_775: usize = 1; -fn aiur_fn_775( - inp: [G; IN_775], +const INPUT_SIZE_771: usize = 2; +const IN_771: usize = 2; +const OUT_771: usize = 1; +fn aiur_fn_771( + inp: [G; IN_771], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_775], ExecError> { +) -> Result<[G; OUT_771], 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_775] = [__v_0]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_0]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __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]; @@ -65394,8 +64973,8 @@ fn aiur_fn_775( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_775] = [__v_7]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_7]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65407,15 +64986,15 @@ fn aiur_fn_775( }) } -const INPUT_SIZE_776: usize = 1; -const IN_776: usize = 1; -const OUT_776: usize = 1; -fn aiur_fn_776( - inp: [G; IN_776], +const INPUT_SIZE_772: usize = 1; +const IN_772: usize = 1; +const OUT_772: usize = 1; +fn aiur_fn_772( + inp: [G; IN_772], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_776], ExecError> { +) -> Result<[G; OUT_772], 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 }; @@ -65427,17 +65006,17 @@ fn aiur_fn_776( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_776] = [__v_6]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_6]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_776] = [__v_8]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_8]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65447,15 +65026,15 @@ fn aiur_fn_776( }) } -const INPUT_SIZE_777: usize = 8; -const IN_777: usize = 8; -const OUT_777: usize = 6; -fn aiur_fn_777( - inp: [G; IN_777], +const INPUT_SIZE_773: usize = 8; +const IN_773: usize = 8; +const OUT_773: usize = 6; +fn aiur_fn_773( + inp: [G; IN_773], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_777], ExecError> { +) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65465,7 +65044,7 @@ fn aiur_fn_777( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -65476,8 +65055,8 @@ fn aiur_fn_777( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65487,15 +65066,15 @@ fn aiur_fn_777( }) } -const INPUT_SIZE_778: usize = 9; -const IN_778: usize = 9; -const OUT_778: usize = 1; -fn aiur_fn_778( - inp: [G; IN_778], +const INPUT_SIZE_774: usize = 9; +const IN_774: usize = 9; +const OUT_774: usize = 1; +fn aiur_fn_774( + inp: [G; IN_774], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_778], ExecError> { +) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65524,17 +65103,17 @@ fn aiur_fn_778( 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_778] = [__v_23]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_23]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __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_778] = [__v_21]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_21]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65544,15 +65123,15 @@ fn aiur_fn_778( }) } -const INPUT_SIZE_779: usize = 1; -const IN_779: usize = 1; -const OUT_779: usize = 1; -fn aiur_fn_779( - inp: [G; IN_779], +const INPUT_SIZE_775: usize = 1; +const IN_775: usize = 1; +const OUT_775: usize = 1; +fn aiur_fn_775( + inp: [G; IN_775], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_779], ExecError> { +) -> Result<[G; OUT_775], 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 }; @@ -65565,17 +65144,17 @@ fn aiur_fn_779( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_779] = [__v_7]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_7]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_779] = [__v_9]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_9]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65585,15 +65164,15 @@ fn aiur_fn_779( }) } -const INPUT_SIZE_780: usize = 2; -const IN_780: usize = 2; -const OUT_780: usize = 1; -fn aiur_fn_780( - inp: [G; IN_780], +const INPUT_SIZE_776: usize = 2; +const IN_776: usize = 2; +const OUT_776: usize = 1; +fn aiur_fn_776( + inp: [G; IN_776], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_780], ExecError> { +) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65603,17 +65182,17 @@ fn aiur_fn_780( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_780] = [__v_1]; - if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_1]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_780] = { let __args: [G; IN_780] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_780] = [__v_7]; - if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_7]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65623,15 +65202,15 @@ fn aiur_fn_780( }) } -const INPUT_SIZE_781: usize = 8; -const IN_781: usize = 8; -const OUT_781: usize = 6; -fn aiur_fn_781( - inp: [G; IN_781], +const INPUT_SIZE_777: usize = 8; +const IN_777: usize = 8; +const OUT_777: usize = 6; +fn aiur_fn_777( + inp: [G; IN_777], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_781], ExecError> { +) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65651,8 +65230,8 @@ fn aiur_fn_781( 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_781] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -65673,22 +65252,22 @@ fn aiur_fn_781( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65698,27 +65277,27 @@ fn aiur_fn_781( 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_781] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65732,15 +65311,15 @@ fn aiur_fn_781( }) } -const INPUT_SIZE_782: usize = 15; -const IN_782: usize = 15; -const OUT_782: usize = 6; -fn aiur_fn_782( - inp: [G; IN_782], +const INPUT_SIZE_778: usize = 15; +const IN_778: usize = 15; +const OUT_778: usize = 6; +fn aiur_fn_778( + inp: [G; IN_778], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_782], ExecError> { +) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65759,38 +65338,38 @@ fn aiur_fn_782( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_783(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } } else { aiur_fn_783(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __ret: [G; OUT_782] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_782] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_783: usize = 14; -const IN_783: usize = 14; -const OUT_783: usize = 6; -fn aiur_fn_783( - inp: [G; IN_783], +const INPUT_SIZE_779: usize = 14; +const IN_779: usize = 14; +const OUT_779: usize = 6; +fn aiur_fn_779( + inp: [G; IN_779], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_783], ExecError> { +) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65830,8 +65409,8 @@ fn aiur_fn_783( 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_783] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65855,8 +65434,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65884,8 +65463,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65909,8 +65488,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65918,8 +65497,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65929,8 +65508,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65958,8 +65537,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65967,8 +65546,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65978,8 +65557,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65991,8 +65570,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66002,8 +65581,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66035,8 +65614,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66060,8 +65639,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66069,8 +65648,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66080,8 +65659,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66109,8 +65688,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66118,8 +65697,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66129,8 +65708,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66142,8 +65721,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66153,8 +65732,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66184,8 +65763,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66213,8 +65792,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66238,8 +65817,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66247,8 +65826,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66258,8 +65837,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66287,8 +65866,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66296,8 +65875,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66307,8 +65886,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66320,8 +65899,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66331,8 +65910,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66364,8 +65943,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66389,8 +65968,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66398,8 +65977,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66409,8 +65988,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66438,8 +66017,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66447,8 +66026,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66458,8 +66037,8 @@ fn aiur_fn_783( 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_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66471,8 +66050,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66482,8 +66061,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66517,8 +66096,8 @@ fn aiur_fn_783( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_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_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66542,8 +66121,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66551,8 +66130,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66562,8 +66141,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66591,8 +66170,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66600,8 +66179,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66611,8 +66190,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66624,8 +66203,8 @@ fn aiur_fn_783( 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_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66635,8 +66214,8 @@ fn aiur_fn_783( 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_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66668,8 +66247,8 @@ fn aiur_fn_783( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_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_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66693,8 +66272,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66702,8 +66281,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66713,8 +66292,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66742,8 +66321,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66751,8 +66330,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66762,8 +66341,8 @@ fn aiur_fn_783( 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_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66775,8 +66354,8 @@ fn aiur_fn_783( 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_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66786,8 +66365,8 @@ fn aiur_fn_783( 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_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -70703,26 +70282,6 @@ pub(crate) fn execute_generated( let __out = aiur_fn_779(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, - 780u64 => { - let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_780(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 781u64 => { - let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_781(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 782u64 => { - let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_782(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 783u64 => { - let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_783(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 051a10e1a..9887d66c4 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -16,8 +16,8 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; -const INPUT_SIZE_0: usize = 3; -const IN_0: usize = 3; +const INPUT_SIZE_0: usize = 2; +const IN_0: usize = 2; const OUT_0: usize = 1; fn aiur_fn_0( inp: [G; IN_0], @@ -25,6 +25,25 @@ fn aiur_fn_0( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __ret: [G; OUT_0] = [__v_2]; + if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_1: usize = 3; +const IN_1: usize = 3; +const OUT_1: usize = 1; +fn aiur_fn_1( + inp: [G; IN_1], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34,8 +53,8 @@ fn aiur_fn_0( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_0] = [__v_5]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_5]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43,29 +62,29 @@ fn aiur_fn_0( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_0] = [__v_10]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_10]; + if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_1: usize = 8; -const IN_1: usize = 8; -const OUT_1: usize = 1; -fn aiur_fn_1( - inp: [G; IN_1], +const INPUT_SIZE_2: usize = 8; +const IN_2: usize = 8; +const OUT_2: usize = 1; +fn aiur_fn_2( + inp: [G; IN_2], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_1], ExecError> { +) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -92,85 +111,85 @@ fn aiur_fn_1( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_8]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_8]; + if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_2: usize = 8; -const IN_2: usize = 8; -const OUT_2: usize = 4; -fn aiur_fn_2( - inp: [G; IN_2], +const INPUT_SIZE_3: usize = 8; +const IN_3: usize = 8; +const OUT_3: usize = 4; +fn aiur_fn_3( + inp: [G; IN_3], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_2], ExecError> { +) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -193,21 +212,21 @@ fn aiur_fn_2( if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __ret: [G; OUT_2] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_3: usize = 12; -const IN_3: usize = 12; -const OUT_3: usize = 4; -fn aiur_fn_3( - inp: [G; IN_3], +const INPUT_SIZE_4: usize = 12; +const IN_4: usize = 12; +const OUT_4: usize = 4; +fn aiur_fn_4( + inp: [G; IN_4], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_3], ExecError> { +) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -240,21 +259,21 @@ fn aiur_fn_3( if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __ret: [G; OUT_3] = [__v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_4: usize = 8; -const IN_4: usize = 8; -const OUT_4: usize = 4; -fn aiur_fn_4( - inp: [G; IN_4], +const INPUT_SIZE_5: usize = 8; +const IN_5: usize = 8; +const OUT_5: usize = 4; +fn aiur_fn_5( + inp: [G; IN_5], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_4], ExecError> { +) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -268,27 +287,7 @@ fn aiur_fn_4( let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; - let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_5: usize = 4; -const IN_5: usize = 4; -const OUT_5: usize = 4; -fn aiur_fn_5( - inp: [G; IN_5], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_5], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1]; + let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -308,14 +307,14 @@ fn aiur_fn_6( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __ret: [G; OUT_6] = [__v_1, __v_2, __v_3, __v_0]; + let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1]; if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_7: usize = 8; -const IN_7: usize = 8; +const INPUT_SIZE_7: usize = 4; +const IN_7: usize = 4; const OUT_7: usize = 4; fn aiur_fn_7( inp: [G; IN_7], @@ -323,6 +322,26 @@ fn aiur_fn_7( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __ret: [G; OUT_7] = [__v_1, __v_2, __v_3, __v_0]; + if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_8: usize = 8; +const IN_8: usize = 8; +const OUT_8: usize = 4; +fn aiur_fn_8( + inp: [G; IN_8], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -348,21 +367,21 @@ fn aiur_fn_7( let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); - let __ret: [G; OUT_7] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_8: usize = 8; -const IN_8: usize = 8; -const OUT_8: usize = 4; -fn aiur_fn_8( - inp: [G; IN_8], +const INPUT_SIZE_9: usize = 8; +const IN_9: usize = 8; +const OUT_9: usize = 4; +fn aiur_fn_9( + inp: [G; IN_9], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_8], ExecError> { +) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -388,21 +407,21 @@ fn aiur_fn_8( let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); - let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_9] = [__v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_9: usize = 8; -const IN_9: usize = 8; -const OUT_9: usize = 8; -fn aiur_fn_9( - inp: [G; IN_9], +const INPUT_SIZE_10: usize = 8; +const IN_10: usize = 8; +const OUT_10: usize = 8; +fn aiur_fn_10( + inp: [G; IN_10], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_9], ExecError> { +) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -436,8 +455,8 @@ fn aiur_fn_9( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -450,8 +469,8 @@ fn aiur_fn_9( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -465,8 +484,8 @@ fn aiur_fn_9( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -479,8 +498,8 @@ fn aiur_fn_9( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -492,8 +511,8 @@ fn aiur_fn_9( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -504,8 +523,8 @@ fn aiur_fn_9( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -515,8 +534,8 @@ fn aiur_fn_9( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __ret: [G; OUT_9] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -525,8 +544,8 @@ fn aiur_fn_9( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); - let __ret: [G; OUT_9] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -534,23 +553,23 @@ fn aiur_fn_9( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); - let __ret: [G; OUT_9] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_10] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_10: usize = 8; -const IN_10: usize = 8; -const OUT_10: usize = 1; -fn aiur_fn_10( - inp: [G; IN_10], +const INPUT_SIZE_11: usize = 8; +const IN_11: usize = 8; +const OUT_11: usize = 1; +fn aiur_fn_11( + inp: [G; IN_11], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_10], ExecError> { +) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -582,21 +601,21 @@ fn aiur_fn_10( let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); - let __ret: [G; OUT_10] = [__v_26]; - if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_11] = [__v_26]; + if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_11: usize = 8; -const IN_11: usize = 8; -const OUT_11: usize = 1; -fn aiur_fn_11( - inp: [G; IN_11], +const INPUT_SIZE_12: usize = 8; +const IN_12: usize = 8; +const OUT_12: usize = 1; +fn aiur_fn_12( + inp: [G; IN_12], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_11], ExecError> { +) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -627,21 +646,21 @@ fn aiur_fn_11( let __v_26: G = (__v_11 + __v_25); let __v_27: G = (__v_9 + __v_26); let __v_28: G = (__v_0 + __v_27); - let __ret: [G; OUT_11] = [__v_28]; - if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_12] = [__v_28]; + if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_12: usize = 8; -const IN_12: usize = 8; -const OUT_12: usize = 1; -fn aiur_fn_12( - inp: [G; IN_12], +const INPUT_SIZE_13: usize = 8; +const IN_13: usize = 8; +const OUT_13: usize = 1; +fn aiur_fn_13( + inp: [G; IN_13], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_12], ExecError> { +) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -666,21 +685,21 @@ fn aiur_fn_12( let __v_20: G = (__v_19 - __v_17); let __v_21: G = (__v_13 * __v_20); let __v_22: G = (__v_18 - __v_21); - let __ret: [G; OUT_12] = [__v_22]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_22]; + if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_13: usize = 1; -const IN_13: usize = 1; -const OUT_13: usize = 8; -fn aiur_fn_13( - inp: [G; IN_13], +const INPUT_SIZE_14: usize = 1; +const IN_14: usize = 1; +const OUT_14: usize = 8; +fn aiur_fn_14( + inp: [G; IN_14], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_13], ExecError> { +) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -739,21 +758,21 @@ fn aiur_fn_13( if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_14: usize = 1; -const IN_14: usize = 1; -const OUT_14: usize = 1; -fn aiur_fn_14( - inp: [G; IN_14], +const INPUT_SIZE_15: usize = 1; +const IN_15: usize = 1; +const OUT_15: usize = 1; +fn aiur_fn_15( + inp: [G; IN_15], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_14], ExecError> { +) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = g_inverse_value(__v_0); @@ -770,21 +789,21 @@ fn aiur_fn_14( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_14] = [__v_1]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_1]; + if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_15: usize = 4; -const IN_15: usize = 4; -const OUT_15: usize = 2; -fn aiur_fn_15( - inp: [G; IN_15], +const INPUT_SIZE_16: usize = 4; +const IN_16: usize = 4; +const OUT_16: usize = 2; +fn aiur_fn_16( + inp: [G; IN_16], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_15], ExecError> { +) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -792,21 +811,21 @@ fn aiur_fn_15( let __v_3: G = inp[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); - let __ret: [G; OUT_15] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_16: usize = 4; -const IN_16: usize = 4; -const OUT_16: usize = 2; -fn aiur_fn_16( - inp: [G; IN_16], +const INPUT_SIZE_17: usize = 4; +const IN_17: usize = 4; +const OUT_17: usize = 2; +fn aiur_fn_17( + inp: [G; IN_17], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_16], ExecError> { +) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -814,21 +833,21 @@ fn aiur_fn_16( let __v_3: G = inp[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); - let __ret: [G; OUT_16] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_17] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_17: usize = 2; -const IN_17: usize = 2; -const OUT_17: usize = 2; -fn aiur_fn_17( - inp: [G; IN_17], +const INPUT_SIZE_18: usize = 2; +const IN_18: usize = 2; +const OUT_18: usize = 2; +fn aiur_fn_18( + inp: [G; IN_18], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_17], ExecError> { +) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -836,21 +855,21 @@ fn aiur_fn_17( let __v_3: G = (__v_2 - __v_0); let __v_4: G = G::from_u64(0); let __v_5: G = (__v_4 - __v_1); - let __ret: [G; OUT_17] = [__v_3, __v_5]; - if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_18] = [__v_3, __v_5]; + if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_18: usize = 4; -const IN_18: usize = 4; -const OUT_18: usize = 2; -fn aiur_fn_18( - inp: [G; IN_18], +const INPUT_SIZE_19: usize = 4; +const IN_19: usize = 4; +const OUT_19: usize = 2; +fn aiur_fn_19( + inp: [G; IN_19], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_18], ExecError> { +) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -864,21 +883,21 @@ fn aiur_fn_18( let __v_9: G = (__v_0 * __v_3); let __v_10: G = (__v_1 * __v_2); let __v_11: G = (__v_9 + __v_10); - let __ret: [G; OUT_18] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_19] = [__v_8, __v_11]; + if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_19: usize = 2; -const IN_19: usize = 2; -const OUT_19: usize = 2; -fn aiur_fn_19( - inp: [G; IN_19], +const INPUT_SIZE_20: usize = 2; +const IN_20: usize = 2; +const OUT_20: usize = 2; +fn aiur_fn_20( + inp: [G; IN_20], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_19], ExecError> { +) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -905,21 +924,21 @@ fn aiur_fn_19( let __v_16: G = G::from_u64(0); let __v_17: G = (__v_16 - __v_1); let __v_18: G = (__v_17 * __v_7); - let __ret: [G; OUT_19] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_20] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_20: usize = 4; -const IN_20: usize = 4; -const OUT_20: usize = 2; -fn aiur_fn_20( - inp: [G; IN_20], +const INPUT_SIZE_21: usize = 4; +const IN_21: usize = 4; +const OUT_21: usize = 2; +fn aiur_fn_21( + inp: [G; IN_21], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_20], ExecError> { +) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -956,21 +975,21 @@ fn aiur_fn_20( let __v_26: G = (__v_0 * __v_20); let __v_27: G = (__v_1 * __v_17); let __v_28: G = (__v_26 + __v_27); - let __ret: [G; OUT_20] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_21] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_21: usize = 4; -const IN_21: usize = 4; -const OUT_21: usize = 1; -fn aiur_fn_21( - inp: [G; IN_21], +const INPUT_SIZE_22: usize = 4; +const IN_22: usize = 4; +const OUT_22: usize = 1; +fn aiur_fn_22( + inp: [G; IN_22], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_21], ExecError> { +) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -981,21 +1000,21 @@ fn aiur_fn_21( let __v_6: G = (__v_1 - __v_3); let __v_7: G = G::from_bool((__v_6 == G::ZERO)); let __v_8: G = (__v_5 * __v_7); - let __ret: [G; OUT_21] = [__v_8]; - if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_22] = [__v_8]; + if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_22: usize = 1; -const IN_22: usize = 1; -const OUT_22: usize = 2; -fn aiur_fn_22( - inp: [G; IN_22], +const INPUT_SIZE_23: usize = 1; +const IN_23: usize = 1; +const OUT_23: usize = 2; +fn aiur_fn_23( + inp: [G; IN_23], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_22], ExecError> { +) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -1004,8 +1023,8 @@ fn aiur_fn_22( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_22] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_2, __v_3]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -1013,8 +1032,8 @@ fn aiur_fn_22( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_22] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -1024,59 +1043,59 @@ fn aiur_fn_22( }) } -const INPUT_SIZE_23: usize = 1; -const IN_23: usize = 1; -const OUT_23: usize = 9; -fn aiur_fn_23( - inp: [G; IN_23], +const INPUT_SIZE_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 9; +fn aiur_fn_24( + inp: [G; IN_24], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_23], ExecError> { +) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_23] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; + if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_24: usize = 1; -const IN_24: usize = 1; -const OUT_24: usize = 2; -fn aiur_fn_24( - inp: [G; IN_24], +const INPUT_SIZE_25: usize = 1; +const IN_25: usize = 1; +const OUT_25: usize = 2; +fn aiur_fn_25( + inp: [G; IN_25], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_24], ExecError> { +) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1086,23 +1105,23 @@ fn aiur_fn_24( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_10, __v_9]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_10, __v_9]; + if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_25: usize = 1; -const IN_25: usize = 1; -const OUT_25: usize = 2; -fn aiur_fn_25( - inp: [G; IN_25], +const INPUT_SIZE_26: usize = 1; +const IN_26: usize = 1; +const OUT_26: usize = 2; +fn aiur_fn_26( + inp: [G; IN_26], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_25], ExecError> { +) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -1110,21 +1129,21 @@ fn aiur_fn_25( let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 + __v_3); - let __ret: [G; OUT_25] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_26] = [__v_2, __v_4]; + if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_26: usize = 1; -const IN_26: usize = 1; -const OUT_26: usize = 9; -fn aiur_fn_26( - inp: [G; IN_26], +const INPUT_SIZE_27: usize = 1; +const IN_27: usize = 1; +const OUT_27: usize = 9; +fn aiur_fn_27( + inp: [G; IN_27], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_26], ExecError> { +) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -1139,24 +1158,24 @@ fn aiur_fn_26( let __v_9: G = __io_read[7]; let __v_10: G = G::from_u64(8); let __v_11: G = (__v_0 + __v_10); - let __ret: [G; OUT_26] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_27] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; + if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_27: usize = 1; -const IN_27: usize = 1; -const OUT_27: usize = 2; -fn aiur_fn_27( - inp: [G; IN_27], +const INPUT_SIZE_28: usize = 1; +const IN_28: usize = 1; +const OUT_28: usize = 2; +fn aiur_fn_28( + inp: [G; IN_28], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_27], ExecError> { +) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1166,26 +1185,26 @@ fn aiur_fn_27( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_27] = [__v_10, __v_9]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_10, __v_9]; + if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_28: usize = 1; -const IN_28: usize = 1; -const OUT_28: usize = 3; -fn aiur_fn_28( - inp: [G; IN_28], +const INPUT_SIZE_29: usize = 1; +const IN_29: usize = 1; +const OUT_29: usize = 3; +fn aiur_fn_29( + inp: [G; IN_29], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_28], ExecError> { +) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1195,7 +1214,7 @@ fn aiur_fn_28( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1247,24 +1266,24 @@ fn aiur_fn_28( let __v_58: G = (__v_43 + __v_57); let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_10 + __v_59); - let __ret: [G; OUT_28] = [__v_39, __v_60, __v_18]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_29] = [__v_39, __v_60, __v_18]; + if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_29: usize = 1; -const IN_29: usize = 1; -const OUT_29: usize = 33; -fn aiur_fn_29( - inp: [G; IN_29], +const INPUT_SIZE_30: usize = 1; +const IN_30: usize = 1; +const OUT_30: usize = 33; +fn aiur_fn_30( + inp: [G; IN_30], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_29], ExecError> { +) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1274,7 +1293,7 @@ fn aiur_fn_29( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1284,7 +1303,7 @@ fn aiur_fn_29( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -1294,7 +1313,7 @@ fn aiur_fn_29( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -1304,44 +1323,44 @@ fn aiur_fn_29( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __ret: [G; OUT_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_30: usize = 1; -const IN_30: usize = 1; -const OUT_30: usize = 2; -fn aiur_fn_30( - inp: [G; IN_30], +const INPUT_SIZE_31: usize = 1; +const IN_31: usize = 1; +const OUT_31: usize = 2; +fn aiur_fn_31( + inp: [G; IN_31], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_30], ExecError> { +) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_30] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_31] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_31: usize = 2; -const IN_31: usize = 2; -const OUT_31: usize = 2; -fn aiur_fn_31( - inp: [G; IN_31], +const INPUT_SIZE_32: usize = 2; +const IN_32: usize = 2; +const OUT_32: usize = 2; +fn aiur_fn_32( + inp: [G; IN_32], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_31], ExecError> { +) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1350,61 +1369,61 @@ fn aiur_fn_31( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_31] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_32] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_31] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_32] = [__v_9, __v_7]; + if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_32: usize = 1; -const IN_32: usize = 1; -const OUT_32: usize = 2; -fn aiur_fn_32( - inp: [G; IN_32], +const INPUT_SIZE_33: usize = 1; +const IN_33: usize = 1; +const OUT_33: usize = 2; +fn aiur_fn_33( + inp: [G; IN_33], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_32], ExecError> { +) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_32] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_33] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_33: usize = 2; -const IN_33: usize = 2; -const OUT_33: usize = 2; -fn aiur_fn_33( - inp: [G; IN_33], +const INPUT_SIZE_34: usize = 2; +const IN_34: usize = 2; +const OUT_34: usize = 2; +fn aiur_fn_34( + inp: [G; IN_34], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_33], ExecError> { +) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1413,12 +1432,12 @@ fn aiur_fn_33( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_33] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1430,51 +1449,51 @@ fn aiur_fn_33( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_33] = [__v_16, __v_14]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_16, __v_14]; + if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_34: usize = 1; -const IN_34: usize = 1; -const OUT_34: usize = 2; -fn aiur_fn_34( - inp: [G; IN_34], +const INPUT_SIZE_35: usize = 1; +const IN_35: usize = 1; +const OUT_35: usize = 2; +fn aiur_fn_35( + inp: [G; IN_35], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_34], ExecError> { +) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_34] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_35] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_35: usize = 2; -const IN_35: usize = 2; -const OUT_35: usize = 2; -fn aiur_fn_35( - inp: [G; IN_35], +const INPUT_SIZE_36: usize = 2; +const IN_36: usize = 2; +const OUT_36: usize = 2; +fn aiur_fn_36( + inp: [G; IN_36], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_35], ExecError> { +) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1483,12 +1502,12 @@ fn aiur_fn_35( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1498,7 +1517,7 @@ fn aiur_fn_35( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1552,51 +1571,51 @@ fn aiur_fn_35( let __v_61: G = (__v_11 + __v_60); let __v_62: G = G::from_u64(1); let __v_63: G = (__v_1 - __v_62); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_67, __v_65]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_67, __v_65]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_36: usize = 1; -const IN_36: usize = 1; -const OUT_36: usize = 2; -fn aiur_fn_36( - inp: [G; IN_36], +const INPUT_SIZE_37: usize = 1; +const IN_37: usize = 1; +const OUT_37: usize = 2; +fn aiur_fn_37( + inp: [G; IN_37], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_36], ExecError> { +) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_36] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_37: usize = 2; -const IN_37: usize = 2; -const OUT_37: usize = 2; -fn aiur_fn_37( - inp: [G; IN_37], +const INPUT_SIZE_38: usize = 2; +const IN_38: usize = 2; +const OUT_38: usize = 2; +fn aiur_fn_38( + inp: [G; IN_38], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_37], ExecError> { +) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1605,12 +1624,12 @@ fn aiur_fn_37( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1620,7 +1639,7 @@ fn aiur_fn_37( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1630,7 +1649,7 @@ fn aiur_fn_37( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -1640,7 +1659,7 @@ fn aiur_fn_37( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -1652,52 +1671,52 @@ fn aiur_fn_37( let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_44, __v_41]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_44, __v_41]; + if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_38: usize = 1; -const IN_38: usize = 1; -const OUT_38: usize = 2; -fn aiur_fn_38( - inp: [G; IN_38], +const INPUT_SIZE_39: usize = 1; +const IN_39: usize = 1; +const OUT_39: usize = 2; +fn aiur_fn_39( + inp: [G; IN_39], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_38], ExecError> { +) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_38] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_39] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_39: usize = 2; -const IN_39: usize = 2; -const OUT_39: usize = 2; -fn aiur_fn_39( - inp: [G; IN_39], +const INPUT_SIZE_40: usize = 2; +const IN_40: usize = 2; +const OUT_40: usize = 2; +fn aiur_fn_40( + inp: [G; IN_40], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_39], ExecError> { +) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1706,61 +1725,61 @@ fn aiur_fn_39( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_9, __v_7]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_40: usize = 1; -const IN_40: usize = 1; -const OUT_40: usize = 2; -fn aiur_fn_40( - inp: [G; IN_40], +const INPUT_SIZE_41: usize = 1; +const IN_41: usize = 1; +const OUT_41: usize = 2; +fn aiur_fn_41( + inp: [G; IN_41], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_40], ExecError> { +) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_40] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_41] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_41: usize = 2; -const IN_41: usize = 2; -const OUT_41: usize = 2; -fn aiur_fn_41( - inp: [G; IN_41], +const INPUT_SIZE_42: usize = 2; +const IN_42: usize = 2; +const OUT_42: usize = 2; +fn aiur_fn_42( + inp: [G; IN_42], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_41], ExecError> { +) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1769,61 +1788,64 @@ fn aiur_fn_41( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_41] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_42] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __v_4: G = G::from_u64(1); - let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = __r_arr[1]; - let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_41] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_42] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_42: usize = 1; -const IN_42: usize = 1; -const OUT_42: usize = 2; -fn aiur_fn_42( - inp: [G; IN_42], +const INPUT_SIZE_43: usize = 1; +const IN_43: usize = 1; +const OUT_43: usize = 2; +fn aiur_fn_43( + inp: [G; IN_43], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_42], ExecError> { +) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_42] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_43: usize = 2; -const IN_43: usize = 2; -const OUT_43: usize = 2; -fn aiur_fn_43( - inp: [G; IN_43], +const INPUT_SIZE_44: usize = 2; +const IN_44: usize = 2; +const OUT_44: usize = 2; +fn aiur_fn_44( + inp: [G; IN_44], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_43], ExecError> { +) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1832,49 +1854,29 @@ fn aiur_fn_43( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_43] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_43] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_9, __v_7]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_44: usize = 1; -const IN_44: usize = 1; -const OUT_44: usize = 2; -fn aiur_fn_44( - inp: [G; IN_44], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_44], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __ret: [G; OUT_44] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_45: usize = 1; const IN_45: usize = 1; const OUT_45: usize = 2; @@ -1886,7 +1888,7 @@ fn aiur_fn_45( ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; @@ -1920,7 +1922,7 @@ fn aiur_fn_46( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); @@ -1940,7 +1942,7 @@ fn aiur_fn_46( const INPUT_SIZE_47: usize = 1; const IN_47: usize = 1; -const OUT_47: usize = 4; +const OUT_47: usize = 2; fn aiur_fn_47( inp: [G; IN_47], record: &mut QueryRecord, @@ -1949,16 +1951,10 @@ fn aiur_fn_47( ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_47] = [__v_1, __v_3, __v_5, __v_6]; + let __ret: [G; OUT_47] = [__v_1, __v_2]; if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -1966,7 +1962,7 @@ fn aiur_fn_47( const INPUT_SIZE_48: usize = 1; const IN_48: usize = 1; -const OUT_48: usize = 3; +const OUT_48: usize = 2; fn aiur_fn_48( inp: [G; IN_48], record: &mut QueryRecord, @@ -1975,23 +1971,20 @@ fn aiur_fn_48( ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_48] = [__v_3, __v_5, __v_6]; + let __ret: [G; OUT_48] = [__v_3, __v_4]; if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_49: usize = 1; -const IN_49: usize = 1; +const INPUT_SIZE_49: usize = 2; +const IN_49: usize = 2; const OUT_49: usize = 2; fn aiur_fn_49( inp: [G; IN_49], @@ -1999,29 +1992,6 @@ fn aiur_fn_49( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_49] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_50: usize = 2; -const IN_50: usize = 2; -const OUT_50: usize = 2; -fn aiur_fn_50( - inp: [G; IN_50], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2029,39 +1999,59 @@ fn aiur_fn_50( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_50] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_49] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_1 - __v_4); + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __v_8: G = G::from_u64(1); - let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_50] = [__v_13, __v_11]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_49] = [__v_9, __v_7]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } +const INPUT_SIZE_50: usize = 1; +const IN_50: usize = 1; +const OUT_50: usize = 4; +fn aiur_fn_50( + inp: [G; IN_50], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_50], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_50] = [__v_1, __v_3, __v_5, __v_6]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + const INPUT_SIZE_51: usize = 1; const IN_51: usize = 1; -const OUT_51: usize = 4; +const OUT_51: usize = 3; fn aiur_fn_51( inp: [G; IN_51], record: &mut QueryRecord, @@ -2070,16 +2060,16 @@ fn aiur_fn_51( ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6]; + let __ret: [G; OUT_51] = [__v_3, __v_5, __v_6]; if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -2096,7 +2086,7 @@ fn aiur_fn_52( ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; @@ -2124,19 +2114,19 @@ fn aiur_fn_53( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_53] = [__v_4, __v_0]; if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); @@ -2145,7 +2135,7 @@ fn aiur_fn_53( let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 5] = [__v_12, __v_2, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_53] = [__v_13, __v_11]; if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); @@ -2156,7 +2146,7 @@ fn aiur_fn_53( const INPUT_SIZE_54: usize = 1; const IN_54: usize = 1; -const OUT_54: usize = 3; +const OUT_54: usize = 4; fn aiur_fn_54( inp: [G; IN_54], record: &mut QueryRecord, @@ -2165,19 +2155,19 @@ fn aiur_fn_54( ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_54] = [__v_3, __v_7, __v_8]; + let __ret: [G; OUT_54] = [__v_1, __v_5, __v_7, __v_8]; if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -2194,7 +2184,7 @@ fn aiur_fn_55( ) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; @@ -2222,22 +2212,22 @@ fn aiur_fn_56( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_56] = [__v_4, __v_0]; if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); @@ -2246,7 +2236,7 @@ fn aiur_fn_56( let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_14, __v_4, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_56] = [__v_15, __v_13]; if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); @@ -2257,7 +2247,7 @@ fn aiur_fn_56( const INPUT_SIZE_57: usize = 1; const IN_57: usize = 1; -const OUT_57: usize = 13; +const OUT_57: usize = 14; fn aiur_fn_57( inp: [G; IN_57], record: &mut QueryRecord, @@ -2266,35 +2256,41 @@ fn aiur_fn_57( ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __v_15: G = __r_arr[2]; - let __v_16: G = __r_arr[3]; - let __v_17: G = __r_arr[4]; - let __v_18: G = __r_arr[5]; - let __v_19: G = __r_arr[6]; - let __v_20: G = __r_arr[7]; - let __v_21: G = __r_arr[8]; - let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __v_23: G = __r_arr[6]; + let __v_24: G = __r_arr[7]; + let __v_25: G = __r_arr[8]; + let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -2311,7 +2307,7 @@ fn aiur_fn_58( ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -2323,7 +2319,7 @@ fn aiur_fn_58( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); @@ -2337,7 +2333,7 @@ fn aiur_fn_58( const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; -const OUT_59: usize = 24; +const OUT_59: usize = 25; fn aiur_fn_59( inp: [G; IN_59], record: &mut QueryRecord, @@ -2346,72 +2342,78 @@ fn aiur_fn_59( ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __v_31: G = __r_arr[2]; - let __v_32: G = __r_arr[3]; - let __v_33: G = __r_arr[4]; - let __v_34: G = __r_arr[5]; - let __v_35: G = __r_arr[6]; - let __v_36: G = __r_arr[7]; - let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_38: G = __r_arr[0]; - let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __v_41: G = __r_arr[1]; - let __v_42: G = __r_arr[2]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_45: G = __r_arr[0]; - let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_32]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = __r_arr[6]; + let __v_40: G = __r_arr[7]; + let __v_41: G = __r_arr[8]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -4394,7 +4396,7 @@ fn aiur_fn_68( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4665,7 +4667,7 @@ fn aiur_fn_69( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -4676,7 +4678,7 @@ fn aiur_fn_69( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -4828,7 +4830,7 @@ fn aiur_fn_69( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -4846,10 +4848,10 @@ fn aiur_fn_69( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -4860,7 +4862,7 @@ fn aiur_fn_69( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -9156,7 +9158,7 @@ fn aiur_fn_94( let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; let __ret: [G; OUT_94] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105]; if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -10240,7 +10242,7 @@ fn aiur_fn_103( let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); @@ -10400,7 +10402,7 @@ fn aiur_fn_103( let __v_270: G = __loaded[5]; let __v_271: G = __loaded[6]; let __v_272: G = __loaded[7]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_273: G = __r_arr[0]; let __v_274: G = __r_arr[1]; let __v_275: G = __r_arr[2]; @@ -10718,9 +10720,9 @@ fn aiur_fn_107( }) } -const INPUT_SIZE_108: usize = 6; -const IN_108: usize = 6; -const OUT_108: usize = 2; +const INPUT_SIZE_108: usize = 2; +const IN_108: usize = 2; +const OUT_108: usize = 1; fn aiur_fn_108( inp: [G; IN_108], record: &mut QueryRecord, @@ -10730,82 +10732,97 @@ fn aiur_fn_108( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_6: G = __loaded[0]; - let __v_7: G = __loaded[1]; - let __v_8: G = __loaded[2]; - match __v_6.as_canonical_u64() { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_108] = [__v_0, __v_9]; + let __ret: [G; OUT_108] = [__v_1]; if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_9: G = __loaded[0]; - let __v_10: G = __loaded[1]; - let __v_11: G = __loaded[2]; - match __v_9.as_canonical_u64() { - 0u64 => { - let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { - 0u64 => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - break '__mc_0 [__v_12]; - }, - _ => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - break '__mc_0 [__v_12]; - }, -} - }; - let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() { - 0u64 => { - break '__mc_1 [__v_12]; - }, - _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - break '__mc_1 [__v_15]; - }, -} - }; - let __v_14: G = __mc_out___mc_1[0]; - let __v_15: G = G::from_u64(1); - let __v_16: G = (__v_5 - __v_15); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_108] = [__v_17, __v_18]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_108] = [__v_0]; if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + match __v_9.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_108] = [__v_17]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_15: G = (__v_3 - __v_9); + let __v_16: G = G::from_bool((__v_15 == G::ZERO)); + match __v_16.as_canonical_u64() { + 1u64 => { + if (__v_6 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); + } + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_108] = [__v_19]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_108] = [__v_19]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_109: usize = 5; -const IN_109: usize = 5; +const INPUT_SIZE_109: usize = 1; +const IN_109: usize = 1; const OUT_109: usize = 2; fn aiur_fn_109( inp: [G; IN_109], @@ -10815,25 +10832,73 @@ fn aiur_fn_109( ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = G::from_u64(1); - let __v_7: G = (__v_4 - __v_6); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_109] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_16, __v_18]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_110: usize = 6; -const IN_110: usize = 6; +const INPUT_SIZE_110: usize = 1; +const IN_110: usize = 1; const OUT_110: usize = 1; fn aiur_fn_110( inp: [G; IN_110], @@ -10843,30 +10908,61 @@ fn aiur_fn_110( ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(1); - let __v_8: G = (__v_5 - __v_7); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = (__v_11 - __v_9); - let __v_13: G = G::from_bool((__v_12 == G::ZERO)); - let __ret: [G; OUT_110] = [__v_13]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_110] = [__v_0]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_110] = [__v_0]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_110] = [__v_17]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_111: usize = 2; -const IN_111: usize = 2; +const INPUT_SIZE_111: usize = 4; +const IN_111: usize = 4; const OUT_111: usize = 1; fn aiur_fn_111( inp: [G; IN_111], @@ -10877,41 +10973,372 @@ fn aiur_fn_111( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - match __v_2.as_canonical_u64() { + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_111] = [__v_1]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_111] = [__v_7]; + let __v_8: G = G::from_u64(0); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_11]; if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_14]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_112: usize = 2; -const IN_112: usize = 2; -const OUT_112: usize = 1; +const INPUT_SIZE_112: usize = 4; +const IN_112: usize = 4; +const OUT_112: usize = 2; fn aiur_fn_112( inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_12, __v_1]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + match __v_5.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = (__v_13 - __v_23); + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 6] = [__v_30, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_31, __v_29]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + match __v_26.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_34, __v_32]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_29, __v_22]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_113: usize = 4; +const IN_113: usize = 4; +const OUT_113: usize = 2; +fn aiur_fn_113( + inp: [G; IN_113], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_113], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_113] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_3 - __v_4); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_3 - __v_8); + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_113] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_114: usize = 6; +const IN_114: usize = 6; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_114], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + match __v_10.as_canonical_u64() { + 0u64 => { + match __v_11.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_16 - __v_17); + let __v_19: G = G::from_bool((__v_18 == G::ZERO)); + let __v_20: G = G::from_u64(1); + if (__v_19 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + if (__v_21 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + if (__v_23 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = (__v_25 - __v_14); + let __v_27: G = G::from_bool((__v_26 == G::ZERO)); + let __ret: [G; OUT_114] = [__v_27]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_115: usize = 2; +const IN_115: usize = 2; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_115], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_115] = [__v_1]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_115] = [__v_7]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_116: usize = 2; +const IN_116: usize = 2; +const OUT_116: usize = 1; +fn aiur_fn_116( + inp: [G; IN_116], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10922,24 +11349,24 @@ fn aiur_fn_112( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_112] = [__v_5]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_5]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_112] = [__v_6]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_6]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); - let __ret: [G; OUT_112] = [__v_7]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_7]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -10951,15 +11378,15 @@ fn aiur_fn_112( }) } -const INPUT_SIZE_113: usize = 8; -const IN_113: usize = 8; -const OUT_113: usize = 2; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_117: usize = 8; +const IN_117: usize = 8; +const OUT_117: usize = 2; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10971,14 +11398,14 @@ fn aiur_fn_113( let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_15 + __v_15); let __v_17: G = (__v_4 + __v_6); @@ -11060,50 +11487,50 @@ fn aiur_fn_113( let __v_81: G = (__v_79 + __v_80); let __v_82: G = (__v_42 + __v_78); let __v_83: G = (__v_45 + __v_81); - let __ret: [G; OUT_113] = [__v_82, __v_83]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_82, __v_83]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_114: usize = 2; -const IN_114: usize = 2; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_118: usize = 2; +const IN_118: usize = 2; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_2 * __v_8); - let __ret: [G; OUT_114] = [__v_9]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_9]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_115: usize = 8; -const IN_115: usize = 8; -const OUT_115: usize = 4; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_119: usize = 8; +const IN_119: usize = 8; +const OUT_119: usize = 4; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11126,8 +11553,8 @@ fn aiur_fn_115( let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_115] = [__v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11180,13 +11607,13 @@ fn aiur_fn_115( let __v_61: G = (__v_6 * __v_3); let __v_62: G = (__v_7 * __v_2); let __v_63: G = (__v_61 + __v_62); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; - let __ret: [G; OUT_115] = [__v_64, __v_65, __v_66, __v_67]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_64, __v_65, __v_66, __v_67]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11201,15 +11628,15 @@ fn aiur_fn_115( }) } -const INPUT_SIZE_116: usize = 2; -const IN_116: usize = 2; -const OUT_116: usize = 1; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_120: usize = 2; +const IN_120: usize = 2; +const OUT_120: usize = 1; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11220,8 +11647,8 @@ fn aiur_fn_116( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_116] = [__v_1]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_1]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11337,14 +11764,14 @@ fn aiur_fn_116( if (__v_94 != __v_95) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; - let __ret: [G; OUT_116] = [__v_98]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_98]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11354,15 +11781,15 @@ fn aiur_fn_116( }) } -const INPUT_SIZE_117: usize = 2; -const IN_117: usize = 2; -const OUT_117: usize = 1; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_121: usize = 2; +const IN_121: usize = 2; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11372,17 +11799,17 @@ fn aiur_fn_117( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_117] = [__v_1]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_1]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_117] = [__v_6]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_6]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11392,15 +11819,15 @@ fn aiur_fn_117( }) } -const INPUT_SIZE_118: usize = 2; -const IN_118: usize = 2; -const OUT_118: usize = 1; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_122: usize = 2; +const IN_122: usize = 2; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11410,17 +11837,17 @@ fn aiur_fn_118( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_118] = [__v_1]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_1]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_118] = [__v_6]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_6]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11430,30 +11857,30 @@ fn aiur_fn_118( }) } -const INPUT_SIZE_119: usize = 3; -const IN_119: usize = 3; -const OUT_119: usize = 1; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_123: usize = 3; +const IN_123: usize = 3; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_119] = [__v_2]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_2]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_119] = [__v_3]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_3]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11463,15 +11890,15 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 2; -const IN_120: usize = 2; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_124: usize = 2; +const IN_124: usize = 2; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11481,8 +11908,8 @@ fn aiur_fn_120( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_120] = [__v_0]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_0]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11494,12 +11921,12 @@ fn aiur_fn_120( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_120] = [__v_14]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_14]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11509,15 +11936,15 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 10; -const IN_121: usize = 10; -const OUT_121: usize = 2; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_125: usize = 10; +const IN_125: usize = 10; +const OUT_125: usize = 2; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11534,17 +11961,17 @@ fn aiur_fn_121( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_0, __v_12]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_0, __v_12]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -11554,23 +11981,23 @@ fn aiur_fn_121( if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_121] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_122: usize = 4; -const IN_122: usize = 4; -const OUT_122: usize = 2; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_126: usize = 4; +const IN_126: usize = 4; +const OUT_126: usize = 2; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11585,8 +12012,8 @@ fn aiur_fn_122( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_9, __v_0]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_9, __v_0]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11603,12 +12030,12 @@ fn aiur_fn_122( let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11627,7 +12054,7 @@ fn aiur_fn_122( let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(0); @@ -11674,8 +12101,8 @@ fn aiur_fn_122( let __v_81: G = (__v_63 + __v_80); let __v_82: G = (__v_28 + __v_81); let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_83, __v_39]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_83, __v_39]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11690,15 +12117,15 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 5; -const IN_123: usize = 5; -const OUT_123: usize = 1; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_127: usize = 5; +const IN_127: usize = 5; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11708,12 +12135,12 @@ fn aiur_fn_123( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_123] = [__v_5]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_5]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -11721,8 +12148,8 @@ fn aiur_fn_123( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_123] = [__v_9]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_9]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11730,10 +12157,10 @@ fn aiur_fn_123( let __v_10: G = (__v_2 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_123] = [__v_13]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_13]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11742,15 +12169,15 @@ fn aiur_fn_123( }) } -const INPUT_SIZE_124: usize = 4; -const IN_124: usize = 4; -const OUT_124: usize = 1; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_128: usize = 4; +const IN_128: usize = 4; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11761,22 +12188,22 @@ fn aiur_fn_124( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_124] = [__v_6]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_6]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_124] = [__v_8]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_8]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11787,11 +12214,11 @@ fn aiur_fn_124( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_124] = [__v_14]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_14]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11800,15 +12227,15 @@ fn aiur_fn_124( }) } -const INPUT_SIZE_125: usize = 8; -const IN_125: usize = 8; -const OUT_125: usize = 1; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_129: usize = 8; +const IN_129: usize = 8; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11831,8 +12258,8 @@ fn aiur_fn_125( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_17]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_17]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11844,7 +12271,7 @@ fn aiur_fn_125( 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11861,17 +12288,17 @@ fn aiur_fn_125( let __v_32: G = (__v_13 + __v_30); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_34]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_34]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_19]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_19]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11885,15 +12312,15 @@ fn aiur_fn_125( }) } -const INPUT_SIZE_126: usize = 2; -const IN_126: usize = 2; -const OUT_126: usize = 1; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_130: usize = 2; +const IN_130: usize = 2; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11908,8 +12335,8 @@ fn aiur_fn_126( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_126] = [__v_9]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_9]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11931,15 +12358,15 @@ fn aiur_fn_126( return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_126] = [__v_19]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_19]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_126] = [__v_11]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_11]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11953,29 +12380,29 @@ fn aiur_fn_126( }) } -const INPUT_SIZE_127: usize = 2; -const IN_127: usize = 2; -const OUT_127: usize = 1; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_127] = [__v_2]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_2]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_127] = [__v_2]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_2]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11985,15 +12412,15 @@ fn aiur_fn_127( }) } -const INPUT_SIZE_128: usize = 10; -const IN_128: usize = 10; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_132: usize = 10; +const IN_132: usize = 10; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12006,17 +12433,17 @@ fn aiur_fn_128( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = (__v_3 - __v_1); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_12 * __v_18); let __v_20: G = G::from_u64(0); @@ -12045,9 +12472,9 @@ fn aiur_fn_128( let __v_37: G = G::from_u64(0); let __v_38: G = (__v_37 - __v_22); let __v_39: G = (__v_38 * __v_28); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_40 - __v_41); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); @@ -12055,23 +12482,23 @@ fn aiur_fn_128( if (__v_43 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_45]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_45]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_129: usize = 11; -const IN_129: usize = 11; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_133: usize = 11; +const IN_133: usize = 11; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12085,12 +12512,12 @@ fn aiur_fn_129( let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = (__v_5 * __v_15); @@ -12101,25 +12528,25 @@ fn aiur_fn_129( let __v_22: G = (__v_5 * __v_16); let __v_23: G = (__v_6 * __v_15); let __v_24: G = (__v_22 + __v_23); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_129] = [__v_26]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_133] = [__v_26]; + if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_130: usize = 13; -const IN_130: usize = 13; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_134: usize = 13; +const IN_134: usize = 13; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12136,43 +12563,43 @@ fn aiur_fn_130( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_130] = [__v_0]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_0]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_4 + __v_18); let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 - __v_20); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_130] = [__v_22]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_22]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_131: usize = 13; -const IN_131: usize = 13; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_135: usize = 13; +const IN_135: usize = 13; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12189,46 +12616,46 @@ fn aiur_fn_131( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_131] = [__v_0]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_0]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_4 + __v_20); let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 - __v_22); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_131] = [__v_24]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_24]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_132: usize = 15; -const IN_132: usize = 15; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_136: usize = 15; +const IN_136: usize = 15; +const OUT_136: usize = 1; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12247,12 +12674,12 @@ fn aiur_fn_132( let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_132] = [__v_0]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_0]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -12261,21 +12688,21 @@ fn aiur_fn_132( let __v_18: G = (__v_4 + __v_17); let __v_19: G = G::from_u64(1); let __v_20: G = (__v_5 - __v_19); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_132] = [__v_21]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_21]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); @@ -12283,10 +12710,10 @@ fn aiur_fn_132( let __v_25: G = (__v_5 - __v_24); let __v_26: G = G::from_u64(1); let __v_27: G = (__v_6 + __v_26); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_132] = [__v_28]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_28]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12298,15 +12725,15 @@ fn aiur_fn_132( }) } -const INPUT_SIZE_133: usize = 15; -const IN_133: usize = 15; -const OUT_133: usize = 1; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_137: usize = 15; +const IN_137: usize = 15; +const OUT_137: usize = 1; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12325,47 +12752,37 @@ fn aiur_fn_133( let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_133] = [__v_0]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_0]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { _ => { - let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __v_23: G = (__v_21 - __v_22); - let __v_24: G = G::from_bool((__v_23 == G::ZERO)); - let __v_25: G = G::from_u64(1); - if (__v_24 != __v_25) { - return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); + let __v_22: G = (__v_20 - __v_21); + let __v_23: G = G::from_bool((__v_22 == G::ZERO)); + let __v_24: G = G::from_u64(1); + if (__v_23 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __v_26: G = (__v_9 - __v_20); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __v_29: G = G::from_u64(1); - if (__v_28 != __v_29) { - return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); - } - let __v_30: G = G::from_u64(0); - let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __ret: [G; OUT_133] = [__v_32]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_27]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12377,15 +12794,15 @@ fn aiur_fn_133( }) } -const INPUT_SIZE_134: usize = 4; -const IN_134: usize = 4; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_138: usize = 4; +const IN_138: usize = 4; +const OUT_138: usize = 1; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12396,39 +12813,39 @@ fn aiur_fn_134( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_134] = [__v_6]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_6]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_5 + __v_1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_134] = [__v_12]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_12]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_135: usize = 1; -const IN_135: usize = 1; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_139: usize = 1; +const IN_139: usize = 1; +const OUT_139: usize = 1; +fn aiur_fn_139( + inp: [G; IN_139], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -12438,23 +12855,23 @@ fn aiur_fn_135( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_135] = [__v_4]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_4]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_135] = [__v_4]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_4]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_135] = [__v_2]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_2]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12466,15 +12883,15 @@ fn aiur_fn_135( }) } -const INPUT_SIZE_136: usize = 5; -const IN_136: usize = 5; -const OUT_136: usize = 1; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_140: usize = 5; +const IN_140: usize = 5; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12486,12 +12903,12 @@ fn aiur_fn_136( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_136] = [__v_7]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_7]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -12500,26 +12917,26 @@ fn aiur_fn_136( let __v_8: G = (__v_3 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_136] = [__v_11]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_11]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_8 + __v_1); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 - __v_10); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_136] = [__v_15]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_15]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12531,15 +12948,15 @@ fn aiur_fn_136( }) } -const INPUT_SIZE_137: usize = 5; -const IN_137: usize = 5; -const OUT_137: usize = 4; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_141: usize = 5; +const IN_141: usize = 5; +const OUT_141: usize = 4; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12548,28 +12965,28 @@ fn aiur_fn_137( let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_1, __v_2, __v_3, __v_4]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_137] = [__v_3, __v_4, __v_1, __v_2]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_3, __v_4, __v_1, __v_2]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_138: usize = 4; -const IN_138: usize = 4; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_142: usize = 4; +const IN_142: usize = 4; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12810,21 +13227,21 @@ fn aiur_fn_138( let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_194]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_194]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_139: usize = 6; -const IN_139: usize = 6; -const OUT_139: usize = 3; -fn aiur_fn_139( - inp: [G; IN_139], +const INPUT_SIZE_143: usize = 6; +const IN_143: usize = 6; +const OUT_143: usize = 3; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12842,8 +13259,8 @@ fn aiur_fn_139( let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -12854,7 +13271,7 @@ fn aiur_fn_139( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); @@ -12867,13 +13284,13 @@ fn aiur_fn_139( let __v_25: G = (__v_23 + __v_24); let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); - let __ret: [G; OUT_139] = [__v_26, __v_27, __v_12]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_26, __v_27, __v_12]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12887,15 +13304,15 @@ fn aiur_fn_139( }) } -const INPUT_SIZE_140: usize = 9; -const IN_140: usize = 9; -const OUT_140: usize = 2; -fn aiur_fn_140( - inp: [G; IN_140], +const INPUT_SIZE_144: usize = 9; +const IN_144: usize = 9; +const OUT_144: usize = 3; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { +) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12906,356 +13323,345 @@ fn aiur_fn_140( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; - let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __v_14: G = (__v_6 - __v_8); - let __v_15: G = G::from_bool((__v_14 == G::ZERO)); - let __v_16: G = G::from_u64(1); - if (__v_15 != __v_16) { - return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None }); + let __v_13: G = (__v_6 - __v_8); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __v_15: G = G::from_u64(1); + if (__v_14 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __v_18: G = G::from_u64(0); - if (__v_17 != __v_18) { - return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(0); + if (__v_16 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_140] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_144] = [__v_0, __v_1, __v_20]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_14: G = __loaded[0]; - let __v_15: G = __loaded[1]; - let __v_16: G = __loaded[2]; - let __v_17: G = __loaded[3]; - match __v_14.as_canonical_u64() { + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_18: G = __loaded[0]; - let __v_19: G = __loaded[1]; - let __v_20: G = __loaded[2]; - match __v_18.as_canonical_u64() { + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_21: G = __loaded[0]; - let __v_22: G = __loaded[1]; - let __v_23: G = __loaded[2]; - match __v_21.as_canonical_u64() { + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { 0u64 => { - let __v_24: G = G::from_u64(1); - let __v_25: G = (__v_6 - __v_24); - let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __v_28: G = __r_arr[1]; - let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() { + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_6 - __v_23); + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() { 0u64 => { - break '__mc_0 [__v_0, __v_1, __v_27, __v_28]; + break '__mc_0 [__v_0, __v_1, __v_26, __v_27]; }, _ => { - break '__mc_0 [__v_27, __v_28, __v_0, __v_1]; + break '__mc_0 [__v_26, __v_27, __v_0, __v_1]; }, } }; - let __v_29: G = __mc_out___mc_0[0]; - let __v_30: G = __mc_out___mc_0[1]; - let __v_31: G = __mc_out___mc_0[2]; - let __v_32: G = __mc_out___mc_0[3]; + let __v_28: G = __mc_out___mc_0[0]; + let __v_29: G = __mc_out___mc_0[1]; + let __v_30: G = __mc_out___mc_0[2]; + let __v_31: G = __mc_out___mc_0[3]; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __gb: [u8; 8] = __v_28.as_canonical_u64().to_le_bytes(); + let __v_40: G = G::from_u8(__gb[0]); + let __v_41: G = G::from_u8(__gb[1]); + let __v_42: G = G::from_u8(__gb[2]); + let __v_43: G = G::from_u8(__gb[3]); + let __v_44: G = G::from_u8(__gb[4]); + let __v_45: G = G::from_u8(__gb[5]); + let __v_46: G = G::from_u8(__gb[6]); + let __v_47: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_48: G = G::from_u64(1020); + let __v_49: G = (__v_47 - __v_48); + let __v_50: G = (__v_46 + __v_49); + let __v_51: G = (__v_45 + __v_50); + let __v_52: G = (__v_44 + __v_51); + let __v_53: G = G::from_bool((__v_52 == G::ZERO)); + let __v_54: G = (__v_42 + __v_43); + let __v_55: G = (__v_41 + __v_54); + let __v_56: G = (__v_40 + __v_55); + let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes(); - let __v_33: G = G::from_u8(__gb[0]); - let __v_34: G = G::from_u8(__gb[1]); - let __v_35: G = G::from_u8(__gb[2]); - let __v_36: G = G::from_u8(__gb[3]); - let __v_37: G = G::from_u8(__gb[4]); - let __v_38: G = G::from_u8(__gb[5]); - let __v_39: G = G::from_u8(__gb[6]); - let __v_40: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_41: G = G::from_u64(1020); - let __v_42: G = (__v_40 - __v_41); - let __v_43: G = (__v_39 + __v_42); - let __v_44: G = (__v_38 + __v_43); - let __v_45: G = (__v_37 + __v_44); - let __v_46: G = G::from_bool((__v_45 == G::ZERO)); - let __v_47: G = (__v_35 + __v_36); - let __v_48: G = (__v_34 + __v_47); - let __v_49: G = (__v_33 + __v_48); - let __v_50: G = G::from_bool((__v_49 == G::ZERO)); + let __v_58: G = G::from_u8(__gb[0]); + let __v_59: G = G::from_u8(__gb[1]); + let __v_60: G = G::from_u8(__gb[2]); + let __v_61: G = G::from_u8(__gb[3]); + let __v_62: G = G::from_u8(__gb[4]); + let __v_63: G = G::from_u8(__gb[5]); + let __v_64: G = G::from_u8(__gb[6]); + let __v_65: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_66: G = G::from_u64(1020); + let __v_67: G = (__v_65 - __v_66); + let __v_68: G = (__v_64 + __v_67); + let __v_69: G = (__v_63 + __v_68); + let __v_70: G = (__v_62 + __v_69); + let __v_71: G = G::from_bool((__v_70 == G::ZERO)); + let __v_72: G = (__v_60 + __v_61); + let __v_73: G = (__v_59 + __v_72); + let __v_74: G = (__v_58 + __v_73); + let __v_75: G = G::from_bool((__v_74 == G::ZERO)); let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); - let __v_51: G = G::from_u8(__gb[0]); - let __v_52: G = G::from_u8(__gb[1]); - let __v_53: G = G::from_u8(__gb[2]); - let __v_54: G = G::from_u8(__gb[3]); - let __v_55: G = G::from_u8(__gb[4]); - let __v_56: G = G::from_u8(__gb[5]); - let __v_57: G = G::from_u8(__gb[6]); - let __v_58: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_57; let __vj = __v_58; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_59: G = G::from_u64(1020); - let __v_60: G = (__v_58 - __v_59); - let __v_61: G = (__v_57 + __v_60); - let __v_62: G = (__v_56 + __v_61); - let __v_63: G = (__v_55 + __v_62); - let __v_64: G = G::from_bool((__v_63 == G::ZERO)); - let __v_65: G = (__v_53 + __v_54); - let __v_66: G = (__v_52 + __v_65); - let __v_67: G = (__v_51 + __v_66); - let __v_68: G = G::from_bool((__v_67 == G::ZERO)); + let __v_76: G = G::from_u8(__gb[0]); + let __v_77: G = G::from_u8(__gb[1]); + let __v_78: G = G::from_u8(__gb[2]); + let __v_79: G = G::from_u8(__gb[3]); + let __v_80: G = G::from_u8(__gb[4]); + let __v_81: G = G::from_u8(__gb[5]); + let __v_82: G = G::from_u8(__gb[6]); + let __v_83: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_84: G = G::from_u64(1020); + let __v_85: G = (__v_83 - __v_84); + let __v_86: G = (__v_82 + __v_85); + let __v_87: G = (__v_81 + __v_86); + let __v_88: G = (__v_80 + __v_87); + let __v_89: G = G::from_bool((__v_88 == G::ZERO)); + let __v_90: G = (__v_78 + __v_79); + let __v_91: G = (__v_77 + __v_90); + let __v_92: G = (__v_76 + __v_91); + let __v_93: G = G::from_bool((__v_92 == G::ZERO)); let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); - let __v_69: G = G::from_u8(__gb[0]); - let __v_70: G = G::from_u8(__gb[1]); - let __v_71: G = G::from_u8(__gb[2]); - let __v_72: G = G::from_u8(__gb[3]); - let __v_73: G = G::from_u8(__gb[4]); - let __v_74: G = G::from_u8(__gb[5]); - let __v_75: G = G::from_u8(__gb[6]); - let __v_76: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_69; let __vj = __v_70; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_75; let __vj = __v_76; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_77: G = G::from_u64(1020); - let __v_78: G = (__v_76 - __v_77); - let __v_79: G = (__v_75 + __v_78); - let __v_80: G = (__v_74 + __v_79); - let __v_81: G = (__v_73 + __v_80); - let __v_82: G = G::from_bool((__v_81 == G::ZERO)); - let __v_83: G = (__v_71 + __v_72); - let __v_84: G = (__v_70 + __v_83); - let __v_85: G = (__v_69 + __v_84); - let __v_86: G = G::from_bool((__v_85 == G::ZERO)); - let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); - let __v_87: G = G::from_u8(__gb[0]); - let __v_88: G = G::from_u8(__gb[1]); - let __v_89: G = G::from_u8(__gb[2]); - let __v_90: G = G::from_u8(__gb[3]); - let __v_91: G = G::from_u8(__gb[4]); - let __v_92: G = G::from_u8(__gb[5]); - let __v_93: G = G::from_u8(__gb[6]); - let __v_94: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_93; let __vj = __v_94; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_95: G = G::from_u64(1020); - let __v_96: G = (__v_94 - __v_95); - let __v_97: G = (__v_93 + __v_96); - let __v_98: G = (__v_92 + __v_97); - let __v_99: G = (__v_91 + __v_98); - let __v_100: G = G::from_bool((__v_99 == G::ZERO)); - let __v_101: G = (__v_89 + __v_90); - let __v_102: G = (__v_88 + __v_101); - let __v_103: G = (__v_87 + __v_102); - let __v_104: G = G::from_bool((__v_103 == G::ZERO)); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __v_105: G = __r_arr[0]; - let __v_106: G = __r_arr[1]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; - let __v_107: G = __r_arr[0]; - let __v_108: G = __r_arr[1]; - let __v_109: G = __r_arr[2]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_110: G = __r_arr[0]; - let __v_111: G = G::from_u64(1); - if (__v_110 != __v_111) { - return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None }); + let __v_94: G = G::from_u8(__gb[0]); + let __v_95: G = G::from_u8(__gb[1]); + let __v_96: G = G::from_u8(__gb[2]); + let __v_97: G = G::from_u8(__gb[3]); + let __v_98: G = G::from_u8(__gb[4]); + let __v_99: G = G::from_u8(__gb[5]); + let __v_100: G = G::from_u8(__gb[6]); + let __v_101: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_94; let __vj = __v_95; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_96; let __vj = __v_97; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_98; let __vj = __v_99; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_100; let __vj = __v_101; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_102: G = G::from_u64(1020); + let __v_103: G = (__v_101 - __v_102); + let __v_104: G = (__v_100 + __v_103); + let __v_105: G = (__v_99 + __v_104); + let __v_106: G = (__v_98 + __v_105); + let __v_107: G = G::from_bool((__v_106 == G::ZERO)); + let __v_108: G = (__v_96 + __v_97); + let __v_109: G = (__v_95 + __v_108); + let __v_110: G = (__v_94 + __v_109); + let __v_111: G = G::from_bool((__v_110 == G::ZERO)); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_112: G = __r_arr[0]; + let __v_113: G = G::from_u64(1); + if (__v_112 != __v_113) { + return Err(ExecError::AssertEqMismatch { lhs: __v_112.as_canonical_u64(), rhs: __v_113.as_canonical_u64(), msg: None }); } - let __v_112: G = G::from_u64(0); - let __v_113: G = G::from_u64(0); - let __v_114: G = G::from_u64(256); - let __v_115: G = (__v_114 * __v_34); - let __v_116: G = G::from_u64(65536); - let __v_117: G = (__v_116 * __v_35); - let __v_118: G = G::from_u64(16777216); - let __v_119: G = (__v_118 * __v_36); - let __v_120: G = G::from_u64(4294967296); - let __v_121: G = (__v_120 * __v_37); - let __v_122: G = G::from_u64(1099511627776); - let __v_123: G = (__v_122 * __v_38); - let __v_124: G = G::from_u64(281474976710656); - let __v_125: G = (__v_124 * __v_39); - let __v_126: G = G::from_u64(72057594037927936); - let __v_127: G = (__v_126 * __v_40); - let __v_128: G = (__v_125 + __v_127); - let __v_129: G = (__v_123 + __v_128); - let __v_130: G = (__v_121 + __v_129); - let __v_131: G = (__v_119 + __v_130); - let __v_132: G = (__v_117 + __v_131); - let __v_133: G = (__v_115 + __v_132); - let __v_134: G = (__v_33 + __v_133); - if (__v_134 != __v_29) { - return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); + let __v_114: G = G::from_u64(0); + let __v_115: G = G::from_u64(0); + let __v_116: G = G::from_u64(256); + let __v_117: G = (__v_116 * __v_41); + let __v_118: G = G::from_u64(65536); + let __v_119: G = (__v_118 * __v_42); + let __v_120: G = G::from_u64(16777216); + let __v_121: G = (__v_120 * __v_43); + let __v_122: G = G::from_u64(4294967296); + let __v_123: G = (__v_122 * __v_44); + let __v_124: G = G::from_u64(1099511627776); + let __v_125: G = (__v_124 * __v_45); + let __v_126: G = G::from_u64(281474976710656); + let __v_127: G = (__v_126 * __v_46); + let __v_128: G = G::from_u64(72057594037927936); + let __v_129: G = (__v_128 * __v_47); + let __v_130: G = (__v_127 + __v_129); + let __v_131: G = (__v_125 + __v_130); + let __v_132: G = (__v_123 + __v_131); + let __v_133: G = (__v_121 + __v_132); + let __v_134: G = (__v_119 + __v_133); + let __v_135: G = (__v_117 + __v_134); + let __v_136: G = (__v_40 + __v_135); + if (__v_136 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } - let __v_135: G = G::from_u64(1); - let __v_136: G = G::from_u64(1); - let __v_137: G = (__v_136 - __v_50); - let __v_138: G = (__v_46 * __v_137); - let __v_139: G = (__v_135 - __v_138); - let __v_140: G = G::from_u64(1); - if (__v_139 != __v_140) { - return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: None }); + let __v_137: G = G::from_u64(1); + let __v_138: G = G::from_u64(1); + let __v_139: G = (__v_138 - __v_57); + let __v_140: G = (__v_53 * __v_139); + let __v_141: G = (__v_137 - __v_140); + let __v_142: G = G::from_u64(1); + if (__v_141 != __v_142) { + return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_142.as_canonical_u64(), msg: None }); } - let __v_141: G = G::from_u64(0); - let __v_142: G = G::from_u64(256); - let __v_143: G = (__v_142 * __v_52); - let __v_144: G = G::from_u64(65536); - let __v_145: G = (__v_144 * __v_53); - let __v_146: G = G::from_u64(16777216); - let __v_147: G = (__v_146 * __v_54); - let __v_148: G = G::from_u64(4294967296); - let __v_149: G = (__v_148 * __v_55); - let __v_150: G = G::from_u64(1099511627776); - let __v_151: G = (__v_150 * __v_56); - let __v_152: G = G::from_u64(281474976710656); - let __v_153: G = (__v_152 * __v_57); - let __v_154: G = G::from_u64(72057594037927936); - let __v_155: G = (__v_154 * __v_58); - let __v_156: G = (__v_153 + __v_155); - let __v_157: G = (__v_151 + __v_156); - let __v_158: G = (__v_149 + __v_157); - let __v_159: G = (__v_147 + __v_158); - let __v_160: G = (__v_145 + __v_159); - let __v_161: G = (__v_143 + __v_160); - let __v_162: G = (__v_51 + __v_161); - if (__v_162 != __v_30) { - return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); + let __v_143: G = G::from_u64(0); + let __v_144: G = G::from_u64(256); + let __v_145: G = (__v_144 * __v_59); + let __v_146: G = G::from_u64(65536); + let __v_147: G = (__v_146 * __v_60); + let __v_148: G = G::from_u64(16777216); + let __v_149: G = (__v_148 * __v_61); + let __v_150: G = G::from_u64(4294967296); + let __v_151: G = (__v_150 * __v_62); + let __v_152: G = G::from_u64(1099511627776); + let __v_153: G = (__v_152 * __v_63); + let __v_154: G = G::from_u64(281474976710656); + let __v_155: G = (__v_154 * __v_64); + let __v_156: G = G::from_u64(72057594037927936); + let __v_157: G = (__v_156 * __v_65); + let __v_158: G = (__v_155 + __v_157); + let __v_159: G = (__v_153 + __v_158); + let __v_160: G = (__v_151 + __v_159); + let __v_161: G = (__v_149 + __v_160); + let __v_162: G = (__v_147 + __v_161); + let __v_163: G = (__v_145 + __v_162); + let __v_164: G = (__v_58 + __v_163); + if (__v_164 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); } - let __v_163: G = G::from_u64(1); - let __v_164: G = G::from_u64(1); - let __v_165: G = (__v_164 - __v_68); - let __v_166: G = (__v_64 * __v_165); - let __v_167: G = (__v_163 - __v_166); - let __v_168: G = G::from_u64(1); - if (__v_167 != __v_168) { - return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: None }); + let __v_165: G = G::from_u64(1); + let __v_166: G = G::from_u64(1); + let __v_167: G = (__v_166 - __v_75); + let __v_168: G = (__v_71 * __v_167); + let __v_169: G = (__v_165 - __v_168); + let __v_170: G = G::from_u64(1); + if (__v_169 != __v_170) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: None }); } - let __v_169: G = G::from_u64(0); - let __v_170: G = G::from_u64(256); - let __v_171: G = (__v_170 * __v_70); - let __v_172: G = G::from_u64(65536); - let __v_173: G = (__v_172 * __v_71); - let __v_174: G = G::from_u64(16777216); - let __v_175: G = (__v_174 * __v_72); - let __v_176: G = G::from_u64(4294967296); - let __v_177: G = (__v_176 * __v_73); - let __v_178: G = G::from_u64(1099511627776); - let __v_179: G = (__v_178 * __v_74); - let __v_180: G = G::from_u64(281474976710656); - let __v_181: G = (__v_180 * __v_75); - let __v_182: G = G::from_u64(72057594037927936); - let __v_183: G = (__v_182 * __v_76); - let __v_184: G = (__v_181 + __v_183); - let __v_185: G = (__v_179 + __v_184); - let __v_186: G = (__v_177 + __v_185); - let __v_187: G = (__v_175 + __v_186); - let __v_188: G = (__v_173 + __v_187); - let __v_189: G = (__v_171 + __v_188); - let __v_190: G = (__v_69 + __v_189); - if (__v_190 != __v_31) { - return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); + let __v_171: G = G::from_u64(0); + let __v_172: G = G::from_u64(256); + let __v_173: G = (__v_172 * __v_77); + let __v_174: G = G::from_u64(65536); + let __v_175: G = (__v_174 * __v_78); + let __v_176: G = G::from_u64(16777216); + let __v_177: G = (__v_176 * __v_79); + let __v_178: G = G::from_u64(4294967296); + let __v_179: G = (__v_178 * __v_80); + let __v_180: G = G::from_u64(1099511627776); + let __v_181: G = (__v_180 * __v_81); + let __v_182: G = G::from_u64(281474976710656); + let __v_183: G = (__v_182 * __v_82); + let __v_184: G = G::from_u64(72057594037927936); + let __v_185: G = (__v_184 * __v_83); + let __v_186: G = (__v_183 + __v_185); + let __v_187: G = (__v_181 + __v_186); + let __v_188: G = (__v_179 + __v_187); + let __v_189: G = (__v_177 + __v_188); + let __v_190: G = (__v_175 + __v_189); + let __v_191: G = (__v_173 + __v_190); + let __v_192: G = (__v_76 + __v_191); + if (__v_192 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } - let __v_191: G = G::from_u64(1); - let __v_192: G = G::from_u64(1); - let __v_193: G = (__v_192 - __v_86); - let __v_194: G = (__v_82 * __v_193); - let __v_195: G = (__v_191 - __v_194); - let __v_196: G = G::from_u64(1); - if (__v_195 != __v_196) { - return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None }); + let __v_193: G = G::from_u64(1); + let __v_194: G = G::from_u64(1); + let __v_195: G = (__v_194 - __v_93); + let __v_196: G = (__v_89 * __v_195); + let __v_197: G = (__v_193 - __v_196); + let __v_198: G = G::from_u64(1); + if (__v_197 != __v_198) { + return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_198.as_canonical_u64(), msg: None }); } - let __v_197: G = G::from_u64(0); - let __v_198: G = G::from_u64(256); - let __v_199: G = (__v_198 * __v_88); - let __v_200: G = G::from_u64(65536); - let __v_201: G = (__v_200 * __v_89); - let __v_202: G = G::from_u64(16777216); - let __v_203: G = (__v_202 * __v_90); - let __v_204: G = G::from_u64(4294967296); - let __v_205: G = (__v_204 * __v_91); - let __v_206: G = G::from_u64(1099511627776); - let __v_207: G = (__v_206 * __v_92); - let __v_208: G = G::from_u64(281474976710656); - let __v_209: G = (__v_208 * __v_93); - let __v_210: G = G::from_u64(72057594037927936); - let __v_211: G = (__v_210 * __v_94); - let __v_212: G = (__v_209 + __v_211); - let __v_213: G = (__v_207 + __v_212); - let __v_214: G = (__v_205 + __v_213); - let __v_215: G = (__v_203 + __v_214); - let __v_216: G = (__v_201 + __v_215); - let __v_217: G = (__v_199 + __v_216); - let __v_218: G = (__v_87 + __v_217); - if (__v_218 != __v_32) { - return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None }); + let __v_199: G = G::from_u64(0); + let __v_200: G = G::from_u64(256); + let __v_201: G = (__v_200 * __v_95); + let __v_202: G = G::from_u64(65536); + let __v_203: G = (__v_202 * __v_96); + let __v_204: G = G::from_u64(16777216); + let __v_205: G = (__v_204 * __v_97); + let __v_206: G = G::from_u64(4294967296); + let __v_207: G = (__v_206 * __v_98); + let __v_208: G = G::from_u64(1099511627776); + let __v_209: G = (__v_208 * __v_99); + let __v_210: G = G::from_u64(281474976710656); + let __v_211: G = (__v_210 * __v_100); + let __v_212: G = G::from_u64(72057594037927936); + let __v_213: G = (__v_212 * __v_101); + let __v_214: G = (__v_211 + __v_213); + let __v_215: G = (__v_209 + __v_214); + let __v_216: G = (__v_207 + __v_215); + let __v_217: G = (__v_205 + __v_216); + let __v_218: G = (__v_203 + __v_217); + let __v_219: G = (__v_201 + __v_218); + let __v_220: G = (__v_94 + __v_219); + if (__v_220 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } - let __v_219: G = G::from_u64(1); - let __v_220: G = G::from_u64(1); - let __v_221: G = (__v_220 - __v_104); - let __v_222: G = (__v_100 * __v_221); - let __v_223: G = (__v_219 - __v_222); - let __v_224: G = G::from_u64(1); - if (__v_223 != __v_224) { - return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_224.as_canonical_u64(), msg: None }); - } - let __v_225: G = G::from_u64(1); + let __v_221: G = G::from_u64(1); + let __v_222: G = G::from_u64(1); + let __v_223: G = (__v_222 - __v_111); + let __v_224: G = (__v_107 * __v_223); + let __v_225: G = (__v_221 - __v_224); let __v_226: G = G::from_u64(1); - let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_232: G = G::from_u64(1); - let __v_233: G = G::from_u64(1); - let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_236: G = G::from_u64(0); - let __v_237: G = G::from_u64(1); - let __v_238: G = G::from_u64(1); - let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_241: G = __r_arr[0]; - let __v_242: G = G::from_u64(1); - if (__v_241 != __v_242) { - return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None }); + if (__v_225 != __v_226) { + return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_226.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; - let __v_243: G = __r_arr[0]; - let __v_244: G = __r_arr[1]; - let __ret: [G; OUT_140] = [__v_243, __v_244]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_227: G = G::from_u64(1); + let __v_228: G = G::from_u64(1); + let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_144] = [__v_37, __v_38, __v_234]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, @@ -13266,15 +13672,15 @@ fn aiur_fn_140( }) } -const INPUT_SIZE_141: usize = 25; -const IN_141: usize = 25; -const OUT_141: usize = 1; -fn aiur_fn_141( - inp: [G; IN_141], +const INPUT_SIZE_145: usize = 25; +const IN_145: usize = 25; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_141], ExecError> { +) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13303,96 +13709,96 @@ fn aiur_fn_141( let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { _ => { - let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_34: G = __r_arr[0]; - let __v_35: G = __r_arr[1]; - match __v_34.as_canonical_u64() { + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + match __v_33.as_canonical_u64() { _ => { - let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(2); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __v_38: G = G::from_u64(2); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __v_40: G = __r_arr[1]; - match __v_39.as_canonical_u64() { + match __v_37.as_canonical_u64() { _ => { - let __v_41: G = G::from_u64(0); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; - let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; - let __v_45: G = __loaded[0]; - let __v_46: G = __loaded[1]; - let __v_47: G = __loaded[2]; - let __v_48: G = __loaded[3]; - let __v_49: G = __loaded[4]; - let __v_50: G = __loaded[5]; - let __v_51: G = __loaded[6]; - match __v_45.as_canonical_u64() { + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_40, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __v_42: G = __loaded[0]; + let __v_43: G = __loaded[1]; + let __v_44: G = __loaded[2]; + let __v_45: G = __loaded[3]; + let __v_46: G = __loaded[4]; + let __v_47: G = __loaded[5]; + let __v_48: G = __loaded[6]; + match __v_42.as_canonical_u64() { 0u64 => { - match __v_46.as_canonical_u64() { + match __v_43.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; - let __v_52: G = __r_arr[0]; - let __v_53: G = __r_arr[1]; - let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = __r_arr[2]; + let __v_52: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_23, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __v_58: G = (__v_57 - __v_24); - let __v_59: G = G::from_bool((__v_58 == G::ZERO)); - let __v_60: G = G::from_u64(1); - if (__v_59 != __v_60) { - return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); + let __v_56: G = (__v_55 - __v_24); + let __v_57: G = G::from_bool((__v_56 == G::ZERO)); + let __v_58: G = G::from_u64(1); + if (__v_57 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __v_62: G = G::from_u64(3); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; - let __v_63: G = __r_arr[0]; - let __v_64: G = (__v_62 + __v_63); - let __v_65: G = (__v_61 - __v_64); - let __v_66: G = G::from_bool((__v_65 == G::ZERO)); - let __v_67: G = G::from_u64(1); - if (__v_66 != __v_67) { - return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); + let __v_62: G = (__v_60 + __v_61); + let __v_63: G = (__v_59 - __v_62); + let __v_64: G = G::from_bool((__v_63 == G::ZERO)); + let __v_65: G = G::from_u64(1); + if (__v_64 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_68: G = __r_arr[0]; - let __v_69: G = (__v_68 - __v_18); - let __v_70: G = G::from_bool((__v_69 == G::ZERO)); - let __v_71: G = G::from_u64(1); - if (__v_70 != __v_71) { - return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = (__v_66 - __v_18); + let __v_68: G = G::from_bool((__v_67 == G::ZERO)); + let __v_69: G = G::from_u64(1); + if (__v_68 != __v_69) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_72: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __v_71: G = (__v_70 - __v_18); + let __v_72: G = G::from_bool((__v_71 == G::ZERO)); let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = (__v_74 - __v_18); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); @@ -13400,50 +13806,29 @@ fn aiur_fn_141( if (__v_76 != __v_77) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_78: G = __r_arr[0]; - let __v_79: G = G::from_u64(1); - if (__v_78 != __v_79) { - return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64(), msg: None }); + let __v_78: G = (__v_43 - __v_20); + let __v_79: G = G::from_bool((__v_78 == G::ZERO)); + let __v_80: G = G::from_u64(1); + if (__v_79 != __v_80) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_80: G = __r_arr[0]; - let __v_81: G = (__v_80 - __v_18); + let __v_81: G = (__v_53 - __v_49); let __v_82: G = G::from_bool((__v_81 == G::ZERO)); - let __v_83: G = G::from_u64(1); - if (__v_82 != __v_83) { - return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_84: G = __r_arr[0]; - let __v_85: G = G::from_u64(1); - if (__v_84 != __v_85) { - return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None }); + let __v_83: G = (__v_54 - __v_50); + let __v_84: G = G::from_bool((__v_83 == G::ZERO)); + let __v_85: G = (__v_82 * __v_84); + let __v_86: G = G::from_u64(1); + if (__v_85 != __v_86) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None }); } - let __v_86: G = (__v_46 - __v_20); - let __v_87: G = G::from_bool((__v_86 == G::ZERO)); - let __v_88: G = G::from_u64(1); - if (__v_87 != __v_88) { - return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); - } - let __v_89: G = (__v_55 - __v_52); - let __v_90: G = G::from_bool((__v_89 == G::ZERO)); - let __v_91: G = (__v_56 - __v_53); - let __v_92: G = G::from_bool((__v_91 == G::ZERO)); - let __v_93: G = (__v_90 * __v_92); - let __v_94: G = G::from_u64(1); - if (__v_93 != __v_94) { - return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None }); - } - let __v_95: G = G::from_u64(1); - let __ret: [G; OUT_141] = [__v_95]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_51]; + if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64())); }, } }, @@ -13457,15 +13842,15 @@ fn aiur_fn_141( }) } -const INPUT_SIZE_142: usize = 25; -const IN_142: usize = 25; -const OUT_142: usize = 1; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_146: usize = 25; +const IN_146: usize = 25; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: [G; IN_146], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13499,40 +13884,511 @@ fn aiur_fn_142( let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { - let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_142] = [__v_29]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_146] = [__v_31]; + if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_146] = [__v_35]; + if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_147: usize = 4; +const IN_147: usize = 4; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: [G; IN_147], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_147], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_6]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_2 - __v_8); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_11]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_148: usize = 2; +const IN_148: usize = 2; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_148], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_148] = [__v_8]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_148] = [__v_9]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_149: usize = 2; +const IN_149: usize = 2; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_149], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_9]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_10]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_150: usize = 4; +const IN_150: usize = 4; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_150], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_6]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_3 - __v_9); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_12]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_151: usize = 13; +const IN_151: usize = 13; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_151], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + _ => { + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + _ => { + let __v_21: G = G::from_u64(2); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + match __v_22.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(1); + if (__v_24 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + if (__v_26 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + if (__v_28 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); + } + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_30: G = G::from_u64(1); + let __ret: [G; OUT_151] = [__v_30]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_30: G = G::from_u64(3); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + match __v_31.as_canonical_u64() { + _ => { + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = (__v_12 - __v_35); + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __ret: [G; OUT_151] = [__v_38]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_152: usize = 2; +const IN_152: usize = 2; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_152], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_152] = [__v_0]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_152] = [__v_8]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_153: usize = 2; +const IN_153: usize = 2; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_153], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_7]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_13]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_154: usize = 6; +const IN_154: usize = 6; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_154], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_bool((__v_11 == G::ZERO)); + let __ret: [G; OUT_154] = [__v_12]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; - let __v_31: G = __r_arr[2]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_142] = [__v_33]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __v_14: G = G::from_u64(1); + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_5 - __v_16); + let __v_18: G = G::from_u64(1); + if (__v_7 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + if (__v_19 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(1); + if (__v_27 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); + } + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_4 + __v_29); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __ret: [G; OUT_154] = [__v_31]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } }, _ => { - return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_143: usize = 31; -const IN_143: usize = 31; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_155: usize = 32; +const IN_155: usize = 32; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: [G; IN_155], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13565,184 +14421,208 @@ fn aiur_fn_143( let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; + let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_31: G = __r_arr[0]; - let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { - break '__mc_0 [__v_34]; + break '__mc_0 [__v_35]; }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_35: G = __r_arr[0]; - break '__mc_0 [__v_35]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + break '__mc_0 [__v_36]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; - let __v_35: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __v_40: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __v_45: G = __r_arr[2]; - let __v_46: G = __r_arr[3]; - let __v_47: G = __r_arr[4]; - let __v_48: G = __r_arr[5]; - let __v_49: G = __r_arr[6]; - let __v_50: G = __r_arr[7]; - let __v_51: G = __r_arr[8]; - let __v_52: G = __r_arr[9]; - let __v_53: G = __r_arr[10]; - let __v_54: G = __r_arr[11]; - let __v_55: G = __r_arr[12]; - let __v_56: G = __r_arr[13]; - let __v_57: G = __r_arr[14]; - let __v_58: G = __r_arr[15]; - let __v_59: G = __r_arr[16]; - let __v_60: G = __r_arr[17]; - let __v_61: G = G::from_u64(256); - let __v_62: G = (__v_61 * __v_44); - let __v_63: G = G::from_u64(65536); - let __v_64: G = (__v_63 * __v_45); - let __v_65: G = G::from_u64(16777216); - let __v_66: G = (__v_65 * __v_46); - let __v_67: G = G::from_u64(4294967296); - let __v_68: G = (__v_67 * __v_47); - let __v_69: G = G::from_u64(1099511627776); - let __v_70: G = (__v_69 * __v_48); - let __v_71: G = G::from_u64(281474976710656); - let __v_72: G = (__v_71 * __v_49); - let __v_73: G = G::from_u64(72057594037927936); - let __v_74: G = (__v_73 * __v_50); - let __v_75: G = (__v_72 + __v_74); - let __v_76: G = (__v_70 + __v_75); - let __v_77: G = (__v_68 + __v_76); - let __v_78: G = (__v_66 + __v_77); - let __v_79: G = (__v_64 + __v_78); - let __v_80: G = (__v_62 + __v_79); - let __v_81: G = (__v_43 + __v_80); - let __v_82: G = G::from_u64(256); - let __v_83: G = (__v_82 * __v_52); - let __v_84: G = G::from_u64(65536); - let __v_85: G = (__v_84 * __v_53); - let __v_86: G = G::from_u64(16777216); - let __v_87: G = (__v_86 * __v_54); - let __v_88: G = G::from_u64(4294967296); - let __v_89: G = (__v_88 * __v_55); - let __v_90: G = G::from_u64(1099511627776); - let __v_91: G = (__v_90 * __v_56); - let __v_92: G = G::from_u64(281474976710656); - let __v_93: G = (__v_92 * __v_57); - let __v_94: G = G::from_u64(72057594037927936); - let __v_95: G = (__v_94 * __v_58); - let __v_96: G = (__v_93 + __v_95); - let __v_97: G = (__v_91 + __v_96); - let __v_98: G = (__v_89 + __v_97); - let __v_99: G = (__v_87 + __v_98); - let __v_100: G = (__v_85 + __v_99); - let __v_101: G = (__v_83 + __v_100); - let __v_102: G = (__v_51 + __v_101); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; - let __v_103: G = __r_arr[0]; - let __v_104: G = __r_arr[1]; - let __v_105: G = G::from_u64(1); + let __v_42: G = G::from_u64(1); + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = __r_arr[9]; + let __v_54: G = __r_arr[10]; + let __v_55: G = __r_arr[11]; + let __v_56: G = __r_arr[12]; + let __v_57: G = __r_arr[13]; + let __v_58: G = __r_arr[14]; + let __v_59: G = __r_arr[15]; + let __v_60: G = __r_arr[16]; + let __v_61: G = __r_arr[17]; + let __v_62: G = G::from_u64(256); + let __v_63: G = (__v_62 * __v_45); + let __v_64: G = G::from_u64(65536); + let __v_65: G = (__v_64 * __v_46); + let __v_66: G = G::from_u64(16777216); + let __v_67: G = (__v_66 * __v_47); + let __v_68: G = G::from_u64(4294967296); + let __v_69: G = (__v_68 * __v_48); + let __v_70: G = G::from_u64(1099511627776); + let __v_71: G = (__v_70 * __v_49); + let __v_72: G = G::from_u64(281474976710656); + let __v_73: G = (__v_72 * __v_50); + let __v_74: G = G::from_u64(72057594037927936); + let __v_75: G = (__v_74 * __v_51); + let __v_76: G = (__v_73 + __v_75); + let __v_77: G = (__v_71 + __v_76); + let __v_78: G = (__v_69 + __v_77); + let __v_79: G = (__v_67 + __v_78); + let __v_80: G = (__v_65 + __v_79); + let __v_81: G = (__v_63 + __v_80); + let __v_82: G = (__v_44 + __v_81); + let __v_83: G = G::from_u64(256); + let __v_84: G = (__v_83 * __v_53); + let __v_85: G = G::from_u64(65536); + let __v_86: G = (__v_85 * __v_54); + let __v_87: G = G::from_u64(16777216); + let __v_88: G = (__v_87 * __v_55); + let __v_89: G = G::from_u64(4294967296); + let __v_90: G = (__v_89 * __v_56); + let __v_91: G = G::from_u64(1099511627776); + let __v_92: G = (__v_91 * __v_57); + let __v_93: G = G::from_u64(281474976710656); + let __v_94: G = (__v_93 * __v_58); + let __v_95: G = G::from_u64(72057594037927936); + let __v_96: G = (__v_95 * __v_59); + let __v_97: G = (__v_94 + __v_96); + let __v_98: G = (__v_92 + __v_97); + let __v_99: G = (__v_90 + __v_98); + let __v_100: G = (__v_88 + __v_99); + let __v_101: G = (__v_86 + __v_100); + let __v_102: G = (__v_84 + __v_101); + let __v_103: G = (__v_52 + __v_102); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __v_104: G = __r_arr[0]; + let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(1); - let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_107: G = G::from_u64(1); + let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_109, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_105, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_110, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_110, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; - let __v_112: G = __r_arr[1]; - let __v_113: G = (__v_31 + __v_27); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_114: G = __r_arr[0]; - let __v_115: G = (__v_114 - __v_31); - let __v_116: G = G::from_bool((__v_115 == G::ZERO)); - let __v_117: G = G::from_u64(1); - if (__v_116 != __v_117) { - return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_112: G = __r_arr[0]; + let __v_113: G = __r_arr[1]; + let __v_114: G = (__v_32 + __v_28); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __v_119: G = (__v_118 - __v_28); - let __v_120: G = G::from_bool((__v_119 == G::ZERO)); - let __v_121: G = G::from_u64(1); - if (__v_120 != __v_121) { - return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_122: G = __r_arr[0]; - let __v_123: G = G::from_u64(1); - if (__v_122 != __v_123) { - return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_119: G = __r_arr[0]; + let __v_120: G = (__v_119 - __v_32); + let __v_121: G = G::from_bool((__v_120 == G::ZERO)); + let __v_122: G = G::from_u64(1); + if (__v_121 != __v_122) { + return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None }); } - let __v_124: G = G::from_u64(33); - let __v_125: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_124.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __v_126: G = G::from_u64(1); - if (__v_125 != __v_126) { - return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_123: G = __r_arr[0]; + let __v_124: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_125: G = __r_arr[0]; + let __v_126: G = (__v_124 + __v_125); + if (__v_123 != __v_126) { + return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_111, __v_112, __v_8, __v_81, __v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_113, __v_103, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; - let __ret: [G; OUT_143] = [__v_127]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_128: G = (__v_127 - __v_32); + let __v_129: G = G::from_bool((__v_128 == G::ZERO)); + let __v_130: G = G::from_u64(1); + if (__v_129 != __v_130) { + return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_131: G = __r_arr[0]; + let __v_132: G = G::from_u64(1); + if (__v_131 != __v_132) { + return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None }); + } + let __v_133: G = G::from_u64(33); + let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_135: G = G::from_u64(1); + if (__v_134 != __v_135) { + return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_136: G = __r_arr[0]; + let __v_137: G = G::from_u64(1); + if (__v_136 != __v_137) { + return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None }); + } + let __v_138: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_139: G = __r_arr[0]; + let __ret: [G; OUT_155] = [__v_139]; + if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_144: usize = 2; -const IN_144: usize = 2; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_156: usize = 2; +const IN_156: usize = 2; +const OUT_156: usize = 1; +fn aiur_fn_156( + inp: [G; IN_156], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { +) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool((__v_0 == G::ZERO)); let __v_3: G = G::from_bool((__v_1 == G::ZERO)); let __v_4: G = (__v_2 * __v_3); - let __ret: [G; OUT_144] = [__v_4]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_156] = [__v_4]; + if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_145: usize = 1; -const IN_145: usize = 1; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_157: usize = 1; +const IN_157: usize = 1; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -13753,8 +14633,8 @@ fn aiur_fn_145( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_145] = [__v_5]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_157] = [__v_5]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13768,15 +14648,15 @@ fn aiur_fn_145( let __v_9: G = G::from_bool((__v_2 == G::ZERO)); let __v_10: G = G::from_bool((__v_3 == G::ZERO)); let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_145] = [__v_11]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_157] = [__v_11]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_145] = [__v_9]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_157] = [__v_9]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -13788,15 +14668,15 @@ fn aiur_fn_145( }) } -const INPUT_SIZE_146: usize = 9; -const IN_146: usize = 9; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], +const INPUT_SIZE_158: usize = 9; +const IN_158: usize = 9; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { +) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13823,21 +14703,21 @@ fn aiur_fn_146( let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_146] = [__v_24]; - if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_24]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_147: usize = 33; -const IN_147: usize = 33; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_159: usize = 33; +const IN_159: usize = 33; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13872,29 +14752,29 @@ fn aiur_fn_147( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_147] = [__v_36]; - if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_159] = [__v_36]; + if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 2; -const IN_148: usize = 2; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_160: usize = 2; +const IN_160: usize = 2; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: [G; IN_160], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13904,8 +14784,8 @@ fn aiur_fn_148( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_148] = [__v_1]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_160] = [__v_1]; + if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13942,18 +14822,18 @@ fn aiur_fn_148( let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __ret: [G; OUT_148] = [__v_41]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_160] = [__v_41]; + if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13963,15 +14843,15 @@ fn aiur_fn_148( }) } -const INPUT_SIZE_149: usize = 2; -const IN_149: usize = 2; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], +const INPUT_SIZE_161: usize = 2; +const IN_161: usize = 2; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13981,8 +14861,8 @@ fn aiur_fn_149( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_149] = [__v_1]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_1]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13993,12 +14873,12 @@ fn aiur_fn_149( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_149] = [__v_13]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_13]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14008,15 +14888,15 @@ fn aiur_fn_149( }) } -const INPUT_SIZE_150: usize = 2; -const IN_150: usize = 2; -const OUT_150: usize = 10; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_162: usize = 2; +const IN_162: usize = 2; +const OUT_162: usize = 10; +fn aiur_fn_162( + inp: [G; IN_162], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14133,7 +15013,7 @@ fn aiur_fn_150( let __v_99: G = G::from_u64(1); let __v_100: G = G::from_u64(1); let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; @@ -14183,8 +15063,8 @@ fn aiur_fn_150( let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_150] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14270,8 +15150,8 @@ fn aiur_fn_150( let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_150] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14316,19 +15196,19 @@ fn aiur_fn_150( }) } -const INPUT_SIZE_151: usize = 2; -const IN_151: usize = 2; -const OUT_151: usize = 10; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_163: usize = 2; +const IN_163: usize = 2; +const OUT_163: usize = 10; +fn aiur_fn_163( + inp: [G; IN_163], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14356,12 +15236,12 @@ fn aiur_fn_151( let __v_26: G = (__v_22 - __v_25); match __v_26.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_151] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -14372,27 +15252,27 @@ fn aiur_fn_151( let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; - let __ret: [G; OUT_151] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_152: usize = 2; -const IN_152: usize = 2; -const OUT_152: usize = 18; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_164: usize = 2; +const IN_164: usize = 2; +const OUT_164: usize = 18; +fn aiur_fn_164( + inp: [G; IN_164], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14403,7 +15283,7 @@ fn aiur_fn_152( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -14414,21 +15294,21 @@ fn aiur_fn_152( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __ret: [G; OUT_152] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_164] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_153: usize = 2; -const IN_153: usize = 2; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_165: usize = 2; +const IN_165: usize = 2; +const OUT_165: usize = 1; +fn aiur_fn_165( + inp: [G; IN_165], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14437,8 +15317,8 @@ fn aiur_fn_153( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_4]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_165] = [__v_4]; + if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14451,11 +15331,11 @@ fn aiur_fn_153( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_9]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_165] = [__v_9]; + if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14467,20 +15347,20 @@ fn aiur_fn_153( }) } -const INPUT_SIZE_154: usize = 3; -const IN_154: usize = 3; -const OUT_154: usize = 3; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_166: usize = 3; +const IN_166: usize = 3; +const OUT_166: usize = 3; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -14530,31 +15410,31 @@ fn aiur_fn_154( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_154] = [__v_52, __v_11, __v_12]; - if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_166] = [__v_52, __v_11, __v_12]; + if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 9; -const IN_155: usize = 9; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_167: usize = 9; +const IN_167: usize = 9; +const OUT_167: usize = 1; +fn aiur_fn_167( + inp: [G; IN_167], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14568,50 +15448,50 @@ fn aiur_fn_155( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_155] = [__v_13]; - if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_167] = [__v_13]; + if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 2; -const IN_156: usize = 2; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_168: usize = 2; +const IN_168: usize = 2; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_156] = [__v_6]; - if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_168] = [__v_6]; + if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 1; -const IN_157: usize = 1; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_169: usize = 1; +const IN_169: usize = 1; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -14656,21 +15536,21 @@ fn aiur_fn_157( let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_157] = [__v_42]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_169] = [__v_42]; + if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_158: usize = 2; -const IN_158: usize = 2; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_170: usize = 2; +const IN_170: usize = 2; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14687,17 +15567,17 @@ fn aiur_fn_158( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_158] = [__v_1]; - if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_170] = [__v_1]; + if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_158] = [__v_13]; - if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_170] = [__v_13]; + if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14707,15 +15587,15 @@ fn aiur_fn_158( }) } -const INPUT_SIZE_159: usize = 2; -const IN_159: usize = 2; -const OUT_159: usize = 1; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_171: usize = 2; +const IN_171: usize = 2; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14724,13 +15604,13 @@ fn aiur_fn_159( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_159] = [__v_4]; - if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_4]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_159] = [__v_1]; - if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_1]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14740,15 +15620,15 @@ fn aiur_fn_159( }) } -const INPUT_SIZE_160: usize = 9; -const IN_160: usize = 9; -const OUT_160: usize = 9; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_172: usize = 9; +const IN_172: usize = 9; +const OUT_172: usize = 9; +fn aiur_fn_172( + inp: [G; IN_172], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14759,15 +15639,15 @@ fn aiur_fn_160( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(109); @@ -14814,7 +15694,7 @@ fn aiur_fn_160( let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -14836,16 +15716,16 @@ fn aiur_fn_160( let __v_77: G = G::from_u64(1); let __v_78: G = G::from_u64(1); let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(1); let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = __r_arr[2]; @@ -14867,25 +15747,25 @@ fn aiur_fn_160( let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); let __v_112: G = G::from_u64(1); let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(1); let __v_117: G = G::from_u64(1); let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __r_arr[2]; @@ -14904,12 +15784,12 @@ fn aiur_fn_160( let __v_134: G = __r_arr[15]; let __v_135: G = __r_arr[16]; let __v_136: G = __r_arr[17]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; @@ -15096,29 +15976,29 @@ fn aiur_fn_160( let __v_324: G = (__v_309 + __v_323); let __v_325: G = (__v_307 + __v_324); let __v_326: G = (__v_149 + __v_325); - let __ret: [G; OUT_160] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; - if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_172] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; + if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 3; -const IN_161: usize = 3; -const OUT_161: usize = 2; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_173: usize = 3; +const IN_173: usize = 3; +const OUT_173: usize = 2; +fn aiur_fn_173( + inp: [G; IN_173], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_161], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_161] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15132,135 +16012,135 @@ fn aiur_fn_161( let __v_10: G = (__v_8 + __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_161] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_162: usize = 1; -const IN_162: usize = 1; -const OUT_162: usize = 1; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_174: usize = 1; +const IN_174: usize = 1; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_162] = [__v_1]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_1]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); - let __ret: [G; OUT_162] = [__v_1]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_1]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); - let __ret: [G; OUT_162] = [__v_4]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_4]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_163: usize = 3; -const IN_163: usize = 3; -const OUT_163: usize = 2; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_175: usize = 3; +const IN_175: usize = 3; +const OUT_175: usize = 2; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); - let __ret: [G; OUT_163] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_164: usize = 1; -const IN_164: usize = 1; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_176: usize = 1; +const IN_176: usize = 1; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_164] = [__v_1]; - if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_1]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); - let __ret: [G; OUT_164] = [__v_5]; - if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_5]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_165: usize = 3; -const IN_165: usize = 3; -const OUT_165: usize = 8; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_177: usize = 3; +const IN_177: usize = 3; +const OUT_177: usize = 8; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); @@ -15371,21 +16251,21 @@ fn aiur_fn_165( let __v_92: G = G::from_u64(0); let __v_93: G = (__v_92 - __v_8); let __v_94: G = (__v_93 * __v_83); - let __ret: [G; OUT_165] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; - if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_177] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; + if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_166: usize = 23; -const IN_166: usize = 23; -const OUT_166: usize = 1; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_178: usize = 24; +const IN_178: usize = 24; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15410,54 +16290,55 @@ fn aiur_fn_166( let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; + let __v_23: G = inp[23]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_23: G = __r_arr[0]; - let __v_24: G = G::from_bool((__v_23 == G::ZERO)); - let __v_25: G = G::from_u64(0); - if (__v_24 != __v_25) { - return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_26: G = __r_arr[0]; - if (__v_26 != __v_23) { - return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + let __v_26: G = G::from_u64(0); + if (__v_25 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - if (__v_27 != __v_23) { - return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); + if (__v_27 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - if (__v_28 != __v_23) { - return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); + if (__v_28 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = G::from_u64(1); - if (__v_29 != __v_30) { - return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); + if (__v_29 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_166] = [__v_31]; - if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); + } + let __v_32: G = G::from_u64(1); + let __ret: [G; OUT_178] = [__v_32]; + if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_167: usize = 6; -const IN_167: usize = 6; -const OUT_167: usize = 2; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_179: usize = 6; +const IN_179: usize = 6; +const OUT_179: usize = 2; +fn aiur_fn_179( + inp: [G; IN_179], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15475,21 +16356,21 @@ fn aiur_fn_167( let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); - let __ret: [G; OUT_167] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_179] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 4; -const IN_168: usize = 4; -const OUT_168: usize = 2; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_180: usize = 4; +const IN_180: usize = 4; +const OUT_180: usize = 2; +fn aiur_fn_180( + inp: [G; IN_180], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_168], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15507,21 +16388,21 @@ fn aiur_fn_168( let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); - let __ret: [G; OUT_168] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_169: usize = 1; -const IN_169: usize = 1; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_181: usize = 1; +const IN_181: usize = 1; +const OUT_181: usize = 1; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -15534,8 +16415,8 @@ fn aiur_fn_169( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_7]; - if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_7]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15547,14 +16428,14 @@ fn aiur_fn_169( match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_13]; - if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_13]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15569,15 +16450,15 @@ fn aiur_fn_169( }) } -const INPUT_SIZE_170: usize = 15; -const IN_170: usize = 15; -const OUT_170: usize = 2; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_182: usize = 15; +const IN_182: usize = 15; +const OUT_182: usize = 2; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15594,7 +16475,7 @@ fn aiur_fn_170( let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -15602,8 +16483,8 @@ fn aiur_fn_170( match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_170] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -15611,109 +16492,109 @@ fn aiur_fn_170( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_170] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_170] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_170] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 + __v_21); let __v_24: G = (__v_20 + __v_22); - let __ret: [G; OUT_170] = [__v_23, __v_24]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_23, __v_24]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 - __v_21); let __v_24: G = (__v_20 - __v_22); - let __ret: [G; OUT_170] = [__v_23, __v_24]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_23, __v_24]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); @@ -15724,20 +16605,20 @@ fn aiur_fn_170( let __v_28: G = (__v_19 * __v_22); let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); - let __ret: [G; OUT_170] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = (__v_21 - __v_19); let __v_23: G = G::from_u64(0); let __v_24: G = (__v_23 - __v_20); - let __ret: [G; OUT_170] = [__v_22, __v_24]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_22, __v_24]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15747,15 +16628,15 @@ fn aiur_fn_170( }) } -const INPUT_SIZE_171: usize = 19; -const IN_171: usize = 19; -const OUT_171: usize = 2; -fn aiur_fn_171( - inp: [G; IN_171], +const INPUT_SIZE_183: usize = 19; +const IN_183: usize = 19; +const OUT_183: usize = 2; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15782,22 +16663,22 @@ fn aiur_fn_171( let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_171] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_171] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15807,15 +16688,15 @@ fn aiur_fn_171( }) } -const INPUT_SIZE_172: usize = 8; -const IN_172: usize = 8; -const OUT_172: usize = 4; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_184: usize = 8; +const IN_184: usize = 8; +const OUT_184: usize = 4; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15871,21 +16752,21 @@ fn aiur_fn_172( let __v_51: G = (__v_15 + __v_33); let __v_52: G = (__v_38 + __v_46); let __v_53: G = (__v_41 + __v_49); - let __ret: [G; OUT_172] = [__v_50, __v_51, __v_52, __v_53]; - if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_50, __v_51, __v_52, __v_53]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 19; -const IN_173: usize = 19; -const OUT_173: usize = 4; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_185: usize = 19; +const IN_185: usize = 19; +const OUT_185: usize = 4; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15916,28 +16797,28 @@ fn aiur_fn_173( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_173] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = (__v_26 + __v_30); let __v_33: G = (__v_27 + __v_31); - let __ret: [G; OUT_173] = [__v_32, __v_33, __v_28, __v_29]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_32, __v_33, __v_28, __v_29]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15947,15 +16828,15 @@ fn aiur_fn_173( }) } -const INPUT_SIZE_174: usize = 44; -const IN_174: usize = 44; -const OUT_174: usize = 2; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_186: usize = 44; +const IN_186: usize = 44; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16008,14 +16889,14 @@ fn aiur_fn_174( let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_174] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -16024,10 +16905,10 @@ fn aiur_fn_174( let __v_53: G = (__v_49 + __v_23); let __v_54: G = (__v_50 + __v_24); let __v_55: G = (__v_51 + __v_25); - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -16052,7 +16933,7 @@ fn aiur_fn_174( let __v_79: G = (__v_77 + __v_78); let __v_80: G = (__v_60 + __v_76); let __v_81: G = (__v_61 + __v_79); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; @@ -16063,23 +16944,23 @@ fn aiur_fn_174( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __v_91: G = __r_arr[1]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_7 + __v_92); let __v_94: G = (__v_7 + __v_93); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = (__v_98 + __v_18); let __v_101: G = (__v_99 + __v_19); let __v_102: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = (__v_103 + __v_20); @@ -16088,23 +16969,23 @@ fn aiur_fn_174( let __v_108: G = (__v_101 - __v_91); let __v_109: G = (__v_105 - __v_95); let __v_110: G = (__v_106 - __v_96); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = __r_arr[2]; let __v_114: G = __r_arr[3]; let __v_115: G = (__v_111 - __v_70); let __v_116: G = (__v_112 - __v_71); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; let __v_119: G = (__v_113 - __v_80); let __v_120: G = (__v_114 - __v_81); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_121, __v_122]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_121, __v_122]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16113,44 +16994,44 @@ fn aiur_fn_174( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); let __v_95: G = (__v_7 + __v_94); let __v_96: G = (__v_7 + __v_95); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = G::from_u64(2); let __v_100: G = (__v_7 + __v_99); let __v_101: G = (__v_7 + __v_100); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = G::from_u64(3); let __v_105: G = (__v_7 + __v_104); let __v_106: G = (__v_7 + __v_105); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = __r_arr[1]; let __v_109: G = (__v_102 - __v_92); let __v_110: G = (__v_103 - __v_93); let __v_111: G = (__v_107 - __v_97); let __v_112: G = (__v_108 - __v_98); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; let __v_115: G = __r_arr[2]; let __v_116: G = __r_arr[3]; let __v_117: G = (__v_113 - __v_70); let __v_118: G = (__v_114 - __v_71); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = (__v_115 - __v_80); let __v_122: G = (__v_116 - __v_81); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; let __v_125: G = G::from_u64(1); @@ -16165,11 +17046,11 @@ fn aiur_fn_174( let __v_134: G = G::from_u64(0); let __v_135: G = G::from_u64(0); let __v_136: G = G::from_u64(0); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_137, __v_138]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_137, __v_138]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16177,11 +17058,11 @@ fn aiur_fn_174( let __v_92: G = (__v_5 + __v_91); let __v_93: G = G::from_u64(1); let __v_94: G = (__v_8 - __v_93); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_95, __v_96]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_95, __v_96]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -16197,15 +17078,15 @@ fn aiur_fn_174( }) } -const INPUT_SIZE_175: usize = 28; -const IN_175: usize = 28; -const OUT_175: usize = 2; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_187: usize = 28; +const IN_187: usize = 28; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16237,7 +17118,7 @@ fn aiur_fn_175( let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); @@ -16294,42 +17175,42 @@ fn aiur_fn_175( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = (__v_83 - __v_86); let __v_89: G = (__v_84 - __v_87); let __v_90: G = (__v_88 + __v_55); let __v_91: G = (__v_89 + __v_58); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = (__v_95 - __v_98); let __v_101: G = (__v_96 - __v_99); let __v_102: G = (__v_100 + __v_74); let __v_103: G = (__v_101 + __v_77); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; - let __ret: [G; OUT_175] = [__v_104, __v_105]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_104, __v_105]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(1); @@ -16340,11 +17221,11 @@ fn aiur_fn_175( let __v_90: G = G::from_u64(0); let __v_91: G = G::from_u64(0); let __v_92: G = G::from_u64(0); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; - let __ret: [G; OUT_175] = [__v_93, __v_94]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_93, __v_94]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16354,15 +17235,15 @@ fn aiur_fn_175( }) } -const INPUT_SIZE_176: usize = 8; -const IN_176: usize = 8; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_188: usize = 8; +const IN_188: usize = 8; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16399,21 +17280,21 @@ fn aiur_fn_176( let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_176] = [__v_34]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_34]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_177: usize = 5; -const IN_177: usize = 5; -const OUT_177: usize = 2; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_189: usize = 5; +const IN_189: usize = 5; +const OUT_189: usize = 2; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16429,8 +17310,8 @@ fn aiur_fn_177( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_177] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16450,13 +17331,13 @@ fn aiur_fn_177( let __v_22: G = (__v_3 * __v_2); let __v_23: G = (__v_4 * __v_1); let __v_24: G = (__v_22 + __v_23); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = (__v_13 + __v_25); let __v_28: G = (__v_16 + __v_26); - let __ret: [G; OUT_177] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16466,145 +17347,145 @@ fn aiur_fn_177( }) } -const INPUT_SIZE_178: usize = 1; -const IN_178: usize = 1; -const OUT_178: usize = 1; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_190: usize = 1; +const IN_190: usize = 1; +const OUT_190: usize = 1; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); - let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_179: usize = 4; -const IN_179: usize = 4; -const OUT_179: usize = 2; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_191: usize = 4; +const IN_191: usize = 4; +const OUT_191: usize = 2; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16618,8 +17499,8 @@ fn aiur_fn_179( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_179] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -16631,21 +17512,21 @@ fn aiur_fn_179( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_179] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_179] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16660,15 +17541,15 @@ fn aiur_fn_179( }) } -const INPUT_SIZE_180: usize = 20; -const IN_180: usize = 20; -const OUT_180: usize = 1; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_192: usize = 20; +const IN_192: usize = 20; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16702,37 +17583,37 @@ fn aiur_fn_180( match __v_20.as_canonical_u64() { 1u64 => { let __v_28: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_28]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_28]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = G::from_u64(1); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() { @@ -16757,13 +17638,13 @@ fn aiur_fn_180( break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -16779,14 +17660,14 @@ fn aiur_fn_180( }; let __v_44: G = __mc_out___mc_0[0]; let __v_45: G = __mc_out___mc_0[1]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(0); let __v_50: G = (__v_46 - __v_48); let __v_51: G = (__v_47 - __v_49); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = g_inverse_value(__v_52); let __v_54: G = (__v_52 * __v_53); @@ -16924,9 +17805,9 @@ fn aiur_fn_180( let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_166: G = __r_arr[0]; let __v_167: G = (__v_165 * __v_166); let __v_168: G = g_inverse_value(__v_167); @@ -16945,7 +17826,7 @@ fn aiur_fn_180( } let __v_176: G = G::from_u64(0); let __v_177: G = G::from_u64(0); - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; let __v_179: G = __r_arr[1]; let __v_180: G = G::from_u64(0); @@ -17002,40 +17883,40 @@ fn aiur_fn_180( let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() { 1u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; let __v_235: G = __r_arr[1]; let __v_236: G = (__v_231 - __v_234); let __v_237: G = (__v_232 - __v_235); let __v_238: G = (__v_236 + __v_203); let __v_239: G = (__v_237 + __v_206); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_246: G = __r_arr[0]; let __v_247: G = __r_arr[1]; let __v_248: G = (__v_243 - __v_246); let __v_249: G = (__v_244 - __v_247); let __v_250: G = (__v_248 + __v_222); let __v_251: G = (__v_249 + __v_225); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_252: G = __r_arr[0]; let __v_253: G = __r_arr[1]; break '__mc_1 [__v_252, __v_253]; }, 0u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = G::from_u64(0); let __v_233: G = G::from_u64(1); @@ -17046,7 +17927,7 @@ fn aiur_fn_180( let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); let __v_240: G = G::from_u64(0); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_241: G = __r_arr[0]; let __v_242: G = __r_arr[1]; break '__mc_1 [__v_241, __v_242]; @@ -17058,19 +17939,19 @@ fn aiur_fn_180( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_232: G = __r_arr[0]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = G::from_u64(1); let __v_239: G = G::from_u64(0); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = (__v_230 * __v_134); @@ -17087,7 +17968,7 @@ fn aiur_fn_180( if (__v_251 != __v_252) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_253: G = __r_arr[0]; let __v_254: G = (__v_253 - __v_29); let __v_255: G = G::from_bool((__v_254 == G::ZERO)); @@ -17106,10 +17987,10 @@ fn aiur_fn_180( } let __v_263: G = G::from_u64(1); let __v_264: G = (__v_9 + __v_263); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_265: G = __r_arr[0]; - let __ret: [G; OUT_180] = [__v_265]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_265]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -17121,15 +18002,15 @@ fn aiur_fn_180( }) } -const INPUT_SIZE_181: usize = 3; -const IN_181: usize = 3; -const OUT_181: usize = 2; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_193: usize = 3; +const IN_193: usize = 3; +const OUT_193: usize = 2; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17149,8 +18030,8 @@ fn aiur_fn_181( 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_181] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -17176,7 +18057,7 @@ fn aiur_fn_181( let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_4 + __v_32); let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); @@ -17189,8 +18070,8 @@ fn aiur_fn_181( let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); - let __ret: [G; OUT_181] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17200,15 +18081,15 @@ fn aiur_fn_181( }) } -const INPUT_SIZE_182: usize = 7; -const IN_182: usize = 7; -const OUT_182: usize = 2; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_194: usize = 7; +const IN_194: usize = 7; +const OUT_194: usize = 2; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17223,12 +18104,12 @@ fn aiur_fn_182( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_182] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); @@ -17258,11 +18139,11 @@ fn aiur_fn_182( let __v_30: G = (__v_29 * __v_19); let __v_31: G = (__v_0 + __v_27); let __v_32: G = (__v_1 + __v_30); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_33, __v_34]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_33, __v_34]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17272,15 +18153,15 @@ fn aiur_fn_182( }) } -const INPUT_SIZE_183: usize = 37; -const IN_183: usize = 37; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_195: usize = 38; +const IN_195: usize = 38; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17319,24 +18200,25 @@ fn aiur_fn_183( let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; + let __v_37: G = inp[37]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { - let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - break '__mc_0 [__v_41]; + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_42]; }, 1u64 => { break '__mc_0 [__v_10]; @@ -17346,522 +18228,557 @@ fn aiur_fn_183( }, } }; - let __v_39: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_17, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_39, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_13, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_12, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __v_45: G = G::from_u64(0); - let __v_46: G = G::from_u64(109); - let __v_47: G = G::from_u64(0); - let __v_48: G = G::from_u64(117); - let __v_49: G = G::from_u64(0); - let __v_50: G = G::from_u64(108); - let __v_51: G = G::from_u64(0); - let __v_52: G = G::from_u64(116); - let __v_53: G = G::from_u64(0); - let __v_54: G = G::from_u64(105); - let __v_55: G = G::from_u64(0); - let __v_56: G = G::from_u64(45); - let __v_57: G = G::from_u64(0); - let __v_58: G = G::from_u64(115); - let __v_59: G = G::from_u64(0); - let __v_60: G = G::from_u64(116); - let __v_61: G = G::from_u64(0); - let __v_62: G = G::from_u64(97); - let __v_63: G = G::from_u64(0); - let __v_64: G = G::from_u64(114); - let __v_65: G = G::from_u64(0); - let __v_66: G = G::from_u64(107); - let __v_67: G = G::from_u64(0); - let __v_68: G = G::from_u64(47); - let __v_69: G = G::from_u64(0); - let __v_70: G = G::from_u64(118); - let __v_71: G = G::from_u64(0); - let __v_72: G = G::from_u64(48); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_76: G = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = G::from_u64(1); + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_7, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(109); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(117); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(108); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(116); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(105); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(45); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(115); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(116); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(97); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(114); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(107); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(47); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(118); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(48); + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_88: G = G::from_u64(1); - let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_90: G = __r_arr[0]; - let __v_91: G = __r_arr[1]; - let __v_92: G = __r_arr[2]; - let __v_93: G = __r_arr[3]; - let __v_94: G = __r_arr[4]; - let __v_95: G = __r_arr[5]; - let __v_96: G = __r_arr[6]; - let __v_97: G = __r_arr[7]; - let __v_98: G = __r_arr[8]; - let __v_99: G = __r_arr[9]; - let __v_100: G = __r_arr[10]; - let __v_101: G = __r_arr[11]; - let __v_102: G = __r_arr[12]; - let __v_103: G = __r_arr[13]; - let __v_104: G = __r_arr[14]; - let __v_105: G = __r_arr[15]; - let __v_106: G = __r_arr[16]; - let __v_107: G = __r_arr[17]; - let __v_108: G = G::from_u64(1); + let __v_89: G = G::from_u64(1); + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = __r_arr[1]; + let __v_93: G = __r_arr[2]; + let __v_94: G = __r_arr[3]; + let __v_95: G = __r_arr[4]; + let __v_96: G = __r_arr[5]; + let __v_97: G = __r_arr[6]; + let __v_98: G = __r_arr[7]; + let __v_99: G = __r_arr[8]; + let __v_100: G = __r_arr[9]; + let __v_101: G = __r_arr[10]; + let __v_102: G = __r_arr[11]; + let __v_103: G = __r_arr[12]; + let __v_104: G = __r_arr[13]; + let __v_105: G = __r_arr[14]; + let __v_106: G = __r_arr[15]; + let __v_107: G = __r_arr[16]; + let __v_108: G = __r_arr[17]; let __v_109: G = G::from_u64(1); - let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_110: G = G::from_u64(1); + let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __v_114: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_107, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); - let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_117: G = __r_arr[0]; - let __v_118: G = __r_arr[1]; - let __v_119: G = __r_arr[2]; - let __v_120: G = __r_arr[3]; - let __v_121: G = __r_arr[4]; - let __v_122: G = __r_arr[5]; - let __v_123: G = __r_arr[6]; - let __v_124: G = __r_arr[7]; - let __v_125: G = __r_arr[8]; - let __v_126: G = __r_arr[9]; - let __v_127: G = __r_arr[10]; - let __v_128: G = __r_arr[11]; - let __v_129: G = __r_arr[12]; - let __v_130: G = __r_arr[13]; - let __v_131: G = __r_arr[14]; - let __v_132: G = __r_arr[15]; - let __v_133: G = __r_arr[16]; - let __v_134: G = __r_arr[17]; - let __v_135: G = G::from_u64(1); + let __v_116: G = G::from_u64(1); + let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_114, __v_117]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_118: G = __r_arr[0]; + let __v_119: G = __r_arr[1]; + let __v_120: G = __r_arr[2]; + let __v_121: G = __r_arr[3]; + let __v_122: G = __r_arr[4]; + let __v_123: G = __r_arr[5]; + let __v_124: G = __r_arr[6]; + let __v_125: G = __r_arr[7]; + let __v_126: G = __r_arr[8]; + let __v_127: G = __r_arr[9]; + let __v_128: G = __r_arr[10]; + let __v_129: G = __r_arr[11]; + let __v_130: G = __r_arr[12]; + let __v_131: G = __r_arr[13]; + let __v_132: G = __r_arr[14]; + let __v_133: G = __r_arr[15]; + let __v_134: G = __r_arr[16]; + let __v_135: G = __r_arr[17]; let __v_136: G = G::from_u64(1); - let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_138: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_137: G = G::from_u64(1); + let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_140: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_140, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_134, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; - let __v_142: G = G::from_u64(1); + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_141, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_142: G = __r_arr[0]; let __v_143: G = G::from_u64(1); - let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_145: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_144: G = G::from_u64(1); + let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_16, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; - let __v_147: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_142, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_147: G = __r_arr[0]; let __v_148: G = G::from_u64(1); - let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_150: G = __r_arr[0]; - let __v_151: G = __r_arr[1]; - let __v_152: G = __r_arr[2]; - let __v_153: G = __r_arr[3]; - let __v_154: G = __r_arr[4]; - let __v_155: G = __r_arr[5]; - let __v_156: G = __r_arr[6]; - let __v_157: G = __r_arr[7]; - let __v_158: G = __r_arr[8]; - let __v_159: G = __r_arr[9]; - let __v_160: G = __r_arr[10]; - let __v_161: G = __r_arr[11]; - let __v_162: G = __r_arr[12]; - let __v_163: G = __r_arr[13]; - let __v_164: G = __r_arr[14]; - let __v_165: G = __r_arr[15]; - let __v_166: G = __r_arr[16]; - let __v_167: G = __r_arr[17]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; - let __v_168: G = __r_arr[0]; - let __v_169: G = G::from_u64(1); + let __v_149: G = G::from_u64(1); + let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_147, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_151: G = __r_arr[0]; + let __v_152: G = __r_arr[1]; + let __v_153: G = __r_arr[2]; + let __v_154: G = __r_arr[3]; + let __v_155: G = __r_arr[4]; + let __v_156: G = __r_arr[5]; + let __v_157: G = __r_arr[6]; + let __v_158: G = __r_arr[7]; + let __v_159: G = __r_arr[8]; + let __v_160: G = __r_arr[9]; + let __v_161: G = __r_arr[10]; + let __v_162: G = __r_arr[11]; + let __v_163: G = __r_arr[12]; + let __v_164: G = __r_arr[13]; + let __v_165: G = __r_arr[14]; + let __v_166: G = __r_arr[15]; + let __v_167: G = __r_arr[16]; + let __v_168: G = __r_arr[17]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_167, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_169: G = __r_arr[0]; let __v_170: G = G::from_u64(1); - let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_172: G = __r_arr[0]; - let __v_173: G = __r_arr[1]; - let __v_174: G = __r_arr[2]; - let __v_175: G = __r_arr[3]; - let __v_176: G = __r_arr[4]; - let __v_177: G = __r_arr[5]; - let __v_178: G = __r_arr[6]; - let __v_179: G = __r_arr[7]; - let __v_180: G = __r_arr[8]; - let __v_181: G = __r_arr[9]; - let __v_182: G = __r_arr[10]; - let __v_183: G = __r_arr[11]; - let __v_184: G = __r_arr[12]; - let __v_185: G = __r_arr[13]; - let __v_186: G = __r_arr[14]; - let __v_187: G = __r_arr[15]; - let __v_188: G = __r_arr[16]; - let __v_189: G = __r_arr[17]; - let __v_190: G = G::from_u64(256); - let __v_191: G = (__v_190 * __v_91); - let __v_192: G = G::from_u64(65536); - let __v_193: G = (__v_192 * __v_92); - let __v_194: G = G::from_u64(16777216); - let __v_195: G = (__v_194 * __v_93); - let __v_196: G = G::from_u64(4294967296); - let __v_197: G = (__v_196 * __v_94); - let __v_198: G = G::from_u64(1099511627776); - let __v_199: G = (__v_198 * __v_95); - let __v_200: G = G::from_u64(281474976710656); - let __v_201: G = (__v_200 * __v_96); - let __v_202: G = G::from_u64(72057594037927936); - let __v_203: G = (__v_202 * __v_97); - let __v_204: G = (__v_201 + __v_203); - let __v_205: G = (__v_199 + __v_204); - let __v_206: G = (__v_197 + __v_205); - let __v_207: G = (__v_195 + __v_206); - let __v_208: G = (__v_193 + __v_207); - let __v_209: G = (__v_191 + __v_208); - let __v_210: G = (__v_90 + __v_209); - let __v_211: G = G::from_u64(256); - let __v_212: G = (__v_211 * __v_99); - let __v_213: G = G::from_u64(65536); - let __v_214: G = (__v_213 * __v_100); - let __v_215: G = G::from_u64(16777216); - let __v_216: G = (__v_215 * __v_101); - let __v_217: G = G::from_u64(4294967296); - let __v_218: G = (__v_217 * __v_102); - let __v_219: G = G::from_u64(1099511627776); - let __v_220: G = (__v_219 * __v_103); - let __v_221: G = G::from_u64(281474976710656); - let __v_222: G = (__v_221 * __v_104); - let __v_223: G = G::from_u64(72057594037927936); - let __v_224: G = (__v_223 * __v_105); - let __v_225: G = (__v_222 + __v_224); - let __v_226: G = (__v_220 + __v_225); - let __v_227: G = (__v_218 + __v_226); - let __v_228: G = (__v_216 + __v_227); - let __v_229: G = (__v_214 + __v_228); - let __v_230: G = (__v_212 + __v_229); - let __v_231: G = (__v_98 + __v_230); - let __v_232: G = G::from_u64(256); - let __v_233: G = (__v_232 * __v_118); - let __v_234: G = G::from_u64(65536); - let __v_235: G = (__v_234 * __v_119); - let __v_236: G = G::from_u64(16777216); - let __v_237: G = (__v_236 * __v_120); - let __v_238: G = G::from_u64(4294967296); - let __v_239: G = (__v_238 * __v_121); - let __v_240: G = G::from_u64(1099511627776); - let __v_241: G = (__v_240 * __v_122); - let __v_242: G = G::from_u64(281474976710656); - let __v_243: G = (__v_242 * __v_123); - let __v_244: G = G::from_u64(72057594037927936); - let __v_245: G = (__v_244 * __v_124); - let __v_246: G = (__v_243 + __v_245); - let __v_247: G = (__v_241 + __v_246); - let __v_248: G = (__v_239 + __v_247); - let __v_249: G = (__v_237 + __v_248); - let __v_250: G = (__v_235 + __v_249); - let __v_251: G = (__v_233 + __v_250); - let __v_252: G = (__v_117 + __v_251); - let __v_253: G = G::from_u64(256); - let __v_254: G = (__v_253 * __v_126); - let __v_255: G = G::from_u64(65536); - let __v_256: G = (__v_255 * __v_127); - let __v_257: G = G::from_u64(16777216); - let __v_258: G = (__v_257 * __v_128); - let __v_259: G = G::from_u64(4294967296); - let __v_260: G = (__v_259 * __v_129); - let __v_261: G = G::from_u64(1099511627776); - let __v_262: G = (__v_261 * __v_130); - let __v_263: G = G::from_u64(281474976710656); - let __v_264: G = (__v_263 * __v_131); - let __v_265: G = G::from_u64(72057594037927936); - let __v_266: G = (__v_265 * __v_132); - let __v_267: G = (__v_264 + __v_266); - let __v_268: G = (__v_262 + __v_267); - let __v_269: G = (__v_260 + __v_268); - let __v_270: G = (__v_258 + __v_269); - let __v_271: G = (__v_256 + __v_270); - let __v_272: G = (__v_254 + __v_271); - let __v_273: G = (__v_125 + __v_272); - let __v_274: G = G::from_u64(256); - let __v_275: G = (__v_274 * __v_151); - let __v_276: G = G::from_u64(65536); - let __v_277: G = (__v_276 * __v_152); - let __v_278: G = G::from_u64(16777216); - let __v_279: G = (__v_278 * __v_153); - let __v_280: G = G::from_u64(4294967296); - let __v_281: G = (__v_280 * __v_154); - let __v_282: G = G::from_u64(1099511627776); - let __v_283: G = (__v_282 * __v_155); - let __v_284: G = G::from_u64(281474976710656); - let __v_285: G = (__v_284 * __v_156); - let __v_286: G = G::from_u64(72057594037927936); - let __v_287: G = (__v_286 * __v_157); - let __v_288: G = (__v_285 + __v_287); - let __v_289: G = (__v_283 + __v_288); - let __v_290: G = (__v_281 + __v_289); - let __v_291: G = (__v_279 + __v_290); - let __v_292: G = (__v_277 + __v_291); - let __v_293: G = (__v_275 + __v_292); - let __v_294: G = (__v_150 + __v_293); - let __v_295: G = G::from_u64(256); - let __v_296: G = (__v_295 * __v_159); - let __v_297: G = G::from_u64(65536); - let __v_298: G = (__v_297 * __v_160); - let __v_299: G = G::from_u64(16777216); - let __v_300: G = (__v_299 * __v_161); - let __v_301: G = G::from_u64(4294967296); - let __v_302: G = (__v_301 * __v_162); - let __v_303: G = G::from_u64(1099511627776); - let __v_304: G = (__v_303 * __v_163); - let __v_305: G = G::from_u64(281474976710656); - let __v_306: G = (__v_305 * __v_164); - let __v_307: G = G::from_u64(72057594037927936); - let __v_308: G = (__v_307 * __v_165); - let __v_309: G = (__v_306 + __v_308); - let __v_310: G = (__v_304 + __v_309); - let __v_311: G = (__v_302 + __v_310); - let __v_312: G = (__v_300 + __v_311); - let __v_313: G = (__v_298 + __v_312); - let __v_314: G = (__v_296 + __v_313); - let __v_315: G = (__v_158 + __v_314); - let __v_316: G = G::from_u64(256); - let __v_317: G = (__v_316 * __v_173); - let __v_318: G = G::from_u64(65536); - let __v_319: G = (__v_318 * __v_174); - let __v_320: G = G::from_u64(16777216); - let __v_321: G = (__v_320 * __v_175); - let __v_322: G = G::from_u64(4294967296); - let __v_323: G = (__v_322 * __v_176); - let __v_324: G = G::from_u64(1099511627776); - let __v_325: G = (__v_324 * __v_177); - let __v_326: G = G::from_u64(281474976710656); - let __v_327: G = (__v_326 * __v_178); - let __v_328: G = G::from_u64(72057594037927936); - let __v_329: G = (__v_328 * __v_179); - let __v_330: G = (__v_327 + __v_329); - let __v_331: G = (__v_325 + __v_330); - let __v_332: G = (__v_323 + __v_331); - let __v_333: G = (__v_321 + __v_332); - let __v_334: G = (__v_319 + __v_333); - let __v_335: G = (__v_317 + __v_334); - let __v_336: G = (__v_172 + __v_335); - let __v_337: G = G::from_u64(256); - let __v_338: G = (__v_337 * __v_181); - let __v_339: G = G::from_u64(65536); - let __v_340: G = (__v_339 * __v_182); - let __v_341: G = G::from_u64(16777216); - let __v_342: G = (__v_341 * __v_183); - let __v_343: G = G::from_u64(4294967296); - let __v_344: G = (__v_343 * __v_184); - let __v_345: G = G::from_u64(1099511627776); - let __v_346: G = (__v_345 * __v_185); - let __v_347: G = G::from_u64(281474976710656); - let __v_348: G = (__v_347 * __v_186); - let __v_349: G = G::from_u64(72057594037927936); - let __v_350: G = (__v_349 * __v_187); - let __v_351: G = (__v_348 + __v_350); - let __v_352: G = (__v_346 + __v_351); - let __v_353: G = (__v_344 + __v_352); - let __v_354: G = (__v_342 + __v_353); - let __v_355: G = (__v_340 + __v_354); - let __v_356: G = (__v_338 + __v_355); - let __v_357: G = (__v_180 + __v_356); - let __v_358: G = G::from_u64(0); + let __v_171: G = G::from_u64(1); + let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_169, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_173: G = __r_arr[0]; + let __v_174: G = __r_arr[1]; + let __v_175: G = __r_arr[2]; + let __v_176: G = __r_arr[3]; + let __v_177: G = __r_arr[4]; + let __v_178: G = __r_arr[5]; + let __v_179: G = __r_arr[6]; + let __v_180: G = __r_arr[7]; + let __v_181: G = __r_arr[8]; + let __v_182: G = __r_arr[9]; + let __v_183: G = __r_arr[10]; + let __v_184: G = __r_arr[11]; + let __v_185: G = __r_arr[12]; + let __v_186: G = __r_arr[13]; + let __v_187: G = __r_arr[14]; + let __v_188: G = __r_arr[15]; + let __v_189: G = __r_arr[16]; + let __v_190: G = __r_arr[17]; + let __v_191: G = G::from_u64(256); + let __v_192: G = (__v_191 * __v_92); + let __v_193: G = G::from_u64(65536); + let __v_194: G = (__v_193 * __v_93); + let __v_195: G = G::from_u64(16777216); + let __v_196: G = (__v_195 * __v_94); + let __v_197: G = G::from_u64(4294967296); + let __v_198: G = (__v_197 * __v_95); + let __v_199: G = G::from_u64(1099511627776); + let __v_200: G = (__v_199 * __v_96); + let __v_201: G = G::from_u64(281474976710656); + let __v_202: G = (__v_201 * __v_97); + let __v_203: G = G::from_u64(72057594037927936); + let __v_204: G = (__v_203 * __v_98); + let __v_205: G = (__v_202 + __v_204); + let __v_206: G = (__v_200 + __v_205); + let __v_207: G = (__v_198 + __v_206); + let __v_208: G = (__v_196 + __v_207); + let __v_209: G = (__v_194 + __v_208); + let __v_210: G = (__v_192 + __v_209); + let __v_211: G = (__v_91 + __v_210); + let __v_212: G = G::from_u64(256); + let __v_213: G = (__v_212 * __v_100); + let __v_214: G = G::from_u64(65536); + let __v_215: G = (__v_214 * __v_101); + let __v_216: G = G::from_u64(16777216); + let __v_217: G = (__v_216 * __v_102); + let __v_218: G = G::from_u64(4294967296); + let __v_219: G = (__v_218 * __v_103); + let __v_220: G = G::from_u64(1099511627776); + let __v_221: G = (__v_220 * __v_104); + let __v_222: G = G::from_u64(281474976710656); + let __v_223: G = (__v_222 * __v_105); + let __v_224: G = G::from_u64(72057594037927936); + let __v_225: G = (__v_224 * __v_106); + let __v_226: G = (__v_223 + __v_225); + let __v_227: G = (__v_221 + __v_226); + let __v_228: G = (__v_219 + __v_227); + let __v_229: G = (__v_217 + __v_228); + let __v_230: G = (__v_215 + __v_229); + let __v_231: G = (__v_213 + __v_230); + let __v_232: G = (__v_99 + __v_231); + let __v_233: G = G::from_u64(256); + let __v_234: G = (__v_233 * __v_119); + let __v_235: G = G::from_u64(65536); + let __v_236: G = (__v_235 * __v_120); + let __v_237: G = G::from_u64(16777216); + let __v_238: G = (__v_237 * __v_121); + let __v_239: G = G::from_u64(4294967296); + let __v_240: G = (__v_239 * __v_122); + let __v_241: G = G::from_u64(1099511627776); + let __v_242: G = (__v_241 * __v_123); + let __v_243: G = G::from_u64(281474976710656); + let __v_244: G = (__v_243 * __v_124); + let __v_245: G = G::from_u64(72057594037927936); + let __v_246: G = (__v_245 * __v_125); + let __v_247: G = (__v_244 + __v_246); + let __v_248: G = (__v_242 + __v_247); + let __v_249: G = (__v_240 + __v_248); + let __v_250: G = (__v_238 + __v_249); + let __v_251: G = (__v_236 + __v_250); + let __v_252: G = (__v_234 + __v_251); + let __v_253: G = (__v_118 + __v_252); + let __v_254: G = G::from_u64(256); + let __v_255: G = (__v_254 * __v_127); + let __v_256: G = G::from_u64(65536); + let __v_257: G = (__v_256 * __v_128); + let __v_258: G = G::from_u64(16777216); + let __v_259: G = (__v_258 * __v_129); + let __v_260: G = G::from_u64(4294967296); + let __v_261: G = (__v_260 * __v_130); + let __v_262: G = G::from_u64(1099511627776); + let __v_263: G = (__v_262 * __v_131); + let __v_264: G = G::from_u64(281474976710656); + let __v_265: G = (__v_264 * __v_132); + let __v_266: G = G::from_u64(72057594037927936); + let __v_267: G = (__v_266 * __v_133); + let __v_268: G = (__v_265 + __v_267); + let __v_269: G = (__v_263 + __v_268); + let __v_270: G = (__v_261 + __v_269); + let __v_271: G = (__v_259 + __v_270); + let __v_272: G = (__v_257 + __v_271); + let __v_273: G = (__v_255 + __v_272); + let __v_274: G = (__v_126 + __v_273); + let __v_275: G = G::from_u64(256); + let __v_276: G = (__v_275 * __v_152); + let __v_277: G = G::from_u64(65536); + let __v_278: G = (__v_277 * __v_153); + let __v_279: G = G::from_u64(16777216); + let __v_280: G = (__v_279 * __v_154); + let __v_281: G = G::from_u64(4294967296); + let __v_282: G = (__v_281 * __v_155); + let __v_283: G = G::from_u64(1099511627776); + let __v_284: G = (__v_283 * __v_156); + let __v_285: G = G::from_u64(281474976710656); + let __v_286: G = (__v_285 * __v_157); + let __v_287: G = G::from_u64(72057594037927936); + let __v_288: G = (__v_287 * __v_158); + let __v_289: G = (__v_286 + __v_288); + let __v_290: G = (__v_284 + __v_289); + let __v_291: G = (__v_282 + __v_290); + let __v_292: G = (__v_280 + __v_291); + let __v_293: G = (__v_278 + __v_292); + let __v_294: G = (__v_276 + __v_293); + let __v_295: G = (__v_151 + __v_294); + let __v_296: G = G::from_u64(256); + let __v_297: G = (__v_296 * __v_160); + let __v_298: G = G::from_u64(65536); + let __v_299: G = (__v_298 * __v_161); + let __v_300: G = G::from_u64(16777216); + let __v_301: G = (__v_300 * __v_162); + let __v_302: G = G::from_u64(4294967296); + let __v_303: G = (__v_302 * __v_163); + let __v_304: G = G::from_u64(1099511627776); + let __v_305: G = (__v_304 * __v_164); + let __v_306: G = G::from_u64(281474976710656); + let __v_307: G = (__v_306 * __v_165); + let __v_308: G = G::from_u64(72057594037927936); + let __v_309: G = (__v_308 * __v_166); + let __v_310: G = (__v_307 + __v_309); + let __v_311: G = (__v_305 + __v_310); + let __v_312: G = (__v_303 + __v_311); + let __v_313: G = (__v_301 + __v_312); + let __v_314: G = (__v_299 + __v_313); + let __v_315: G = (__v_297 + __v_314); + let __v_316: G = (__v_159 + __v_315); + let __v_317: G = G::from_u64(256); + let __v_318: G = (__v_317 * __v_174); + let __v_319: G = G::from_u64(65536); + let __v_320: G = (__v_319 * __v_175); + let __v_321: G = G::from_u64(16777216); + let __v_322: G = (__v_321 * __v_176); + let __v_323: G = G::from_u64(4294967296); + let __v_324: G = (__v_323 * __v_177); + let __v_325: G = G::from_u64(1099511627776); + let __v_326: G = (__v_325 * __v_178); + let __v_327: G = G::from_u64(281474976710656); + let __v_328: G = (__v_327 * __v_179); + let __v_329: G = G::from_u64(72057594037927936); + let __v_330: G = (__v_329 * __v_180); + let __v_331: G = (__v_328 + __v_330); + let __v_332: G = (__v_326 + __v_331); + let __v_333: G = (__v_324 + __v_332); + let __v_334: G = (__v_322 + __v_333); + let __v_335: G = (__v_320 + __v_334); + let __v_336: G = (__v_318 + __v_335); + let __v_337: G = (__v_173 + __v_336); + let __v_338: G = G::from_u64(256); + let __v_339: G = (__v_338 * __v_182); + let __v_340: G = G::from_u64(65536); + let __v_341: G = (__v_340 * __v_183); + let __v_342: G = G::from_u64(16777216); + let __v_343: G = (__v_342 * __v_184); + let __v_344: G = G::from_u64(4294967296); + let __v_345: G = (__v_344 * __v_185); + let __v_346: G = G::from_u64(1099511627776); + let __v_347: G = (__v_346 * __v_186); + let __v_348: G = G::from_u64(281474976710656); + let __v_349: G = (__v_348 * __v_187); + let __v_350: G = G::from_u64(72057594037927936); + let __v_351: G = (__v_350 * __v_188); + let __v_352: G = (__v_349 + __v_351); + let __v_353: G = (__v_347 + __v_352); + let __v_354: G = (__v_345 + __v_353); + let __v_355: G = (__v_343 + __v_354); + let __v_356: G = (__v_341 + __v_355); + let __v_357: G = (__v_339 + __v_356); + let __v_358: G = (__v_181 + __v_357); let __v_359: G = G::from_u64(0); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - let __v_361: G = __r_arr[1]; - let __v_362: G = G::from_u64(0); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; - let __v_363: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_360: G = G::from_u64(0); + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __v_361: G = __r_arr[0]; + let __v_362: G = __r_arr[1]; + let __v_363: G = G::from_u64(0); + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_365: G = __r_arr[0]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_365: G = __r_arr[0]; - let __v_366: G = G::from_u64(1); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); - let __v_368: G = { let __values: [G; 3] = [__v_366, __v_367, __v_367]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_31.as_canonical_u64() { + let __v_368: G = G::from_u64(1); + let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() { 0u64 => { - break '__mc_1 [__v_368]; + break '__mc_1 [__v_369]; }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_369: G = __r_arr[0]; - break '__mc_1 [__v_369]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_33, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_370: G = __r_arr[0]; + break '__mc_1 [__v_370]; }, _ => { - return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); }, } }; - let __v_369: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_370: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_370: G = __mc_out___mc_1[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_31, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_371: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_33, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_35, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_372: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_34, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_373: G = __r_arr[0]; - let __v_374: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_189, __v_373]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_374: G = __r_arr[0]; let __v_375: G = G::from_u64(1); - let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_377: G = __r_arr[0]; - let __v_378: G = __r_arr[1]; - let __v_379: G = __r_arr[2]; - let __v_380: G = __r_arr[3]; - let __v_381: G = __r_arr[4]; - let __v_382: G = __r_arr[5]; - let __v_383: G = __r_arr[6]; - let __v_384: G = __r_arr[7]; - let __v_385: G = __r_arr[8]; - let __v_386: G = __r_arr[9]; - let __v_387: G = __r_arr[10]; - let __v_388: G = __r_arr[11]; - let __v_389: G = __r_arr[12]; - let __v_390: G = __r_arr[13]; - let __v_391: G = __r_arr[14]; - let __v_392: G = __r_arr[15]; - let __v_393: G = __r_arr[16]; - let __v_394: G = __r_arr[17]; - let __v_395: G = G::from_u64(256); - let __v_396: G = (__v_395 * __v_378); - let __v_397: G = G::from_u64(65536); - let __v_398: G = (__v_397 * __v_379); - let __v_399: G = G::from_u64(16777216); - let __v_400: G = (__v_399 * __v_380); - let __v_401: G = G::from_u64(4294967296); - let __v_402: G = (__v_401 * __v_381); - let __v_403: G = G::from_u64(1099511627776); - let __v_404: G = (__v_403 * __v_382); - let __v_405: G = G::from_u64(281474976710656); - let __v_406: G = (__v_405 * __v_383); - let __v_407: G = G::from_u64(72057594037927936); - let __v_408: G = (__v_407 * __v_384); - let __v_409: G = (__v_406 + __v_408); - let __v_410: G = (__v_404 + __v_409); - let __v_411: G = (__v_402 + __v_410); - let __v_412: G = (__v_400 + __v_411); - let __v_413: G = (__v_398 + __v_412); - let __v_414: G = (__v_396 + __v_413); - let __v_415: G = (__v_377 + __v_414); - let __v_416: G = G::from_u64(256); - let __v_417: G = (__v_416 * __v_386); - let __v_418: G = G::from_u64(65536); - let __v_419: G = (__v_418 * __v_387); - let __v_420: G = G::from_u64(16777216); - let __v_421: G = (__v_420 * __v_388); - let __v_422: G = G::from_u64(4294967296); - let __v_423: G = (__v_422 * __v_389); - let __v_424: G = G::from_u64(1099511627776); - let __v_425: G = (__v_424 * __v_390); - let __v_426: G = G::from_u64(281474976710656); - let __v_427: G = (__v_426 * __v_391); - let __v_428: G = G::from_u64(72057594037927936); - let __v_429: G = (__v_428 * __v_392); - let __v_430: G = (__v_427 + __v_429); - let __v_431: G = (__v_425 + __v_430); - let __v_432: G = (__v_423 + __v_431); - let __v_433: G = (__v_421 + __v_432); - let __v_434: G = (__v_419 + __v_433); - let __v_435: G = (__v_417 + __v_434); - let __v_436: G = (__v_385 + __v_435); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; - let __v_437: G = __r_arr[0]; - let __v_438: G = __r_arr[1]; - let __v_439: G = G::from_u64(1); + let __v_376: G = G::from_u64(1); + let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_374, __v_377]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_378: G = __r_arr[0]; + let __v_379: G = __r_arr[1]; + let __v_380: G = __r_arr[2]; + let __v_381: G = __r_arr[3]; + let __v_382: G = __r_arr[4]; + let __v_383: G = __r_arr[5]; + let __v_384: G = __r_arr[6]; + let __v_385: G = __r_arr[7]; + let __v_386: G = __r_arr[8]; + let __v_387: G = __r_arr[9]; + let __v_388: G = __r_arr[10]; + let __v_389: G = __r_arr[11]; + let __v_390: G = __r_arr[12]; + let __v_391: G = __r_arr[13]; + let __v_392: G = __r_arr[14]; + let __v_393: G = __r_arr[15]; + let __v_394: G = __r_arr[16]; + let __v_395: G = __r_arr[17]; + let __v_396: G = G::from_u64(256); + let __v_397: G = (__v_396 * __v_379); + let __v_398: G = G::from_u64(65536); + let __v_399: G = (__v_398 * __v_380); + let __v_400: G = G::from_u64(16777216); + let __v_401: G = (__v_400 * __v_381); + let __v_402: G = G::from_u64(4294967296); + let __v_403: G = (__v_402 * __v_382); + let __v_404: G = G::from_u64(1099511627776); + let __v_405: G = (__v_404 * __v_383); + let __v_406: G = G::from_u64(281474976710656); + let __v_407: G = (__v_406 * __v_384); + let __v_408: G = G::from_u64(72057594037927936); + let __v_409: G = (__v_408 * __v_385); + let __v_410: G = (__v_407 + __v_409); + let __v_411: G = (__v_405 + __v_410); + let __v_412: G = (__v_403 + __v_411); + let __v_413: G = (__v_401 + __v_412); + let __v_414: G = (__v_399 + __v_413); + let __v_415: G = (__v_397 + __v_414); + let __v_416: G = (__v_378 + __v_415); + let __v_417: G = G::from_u64(256); + let __v_418: G = (__v_417 * __v_387); + let __v_419: G = G::from_u64(65536); + let __v_420: G = (__v_419 * __v_388); + let __v_421: G = G::from_u64(16777216); + let __v_422: G = (__v_421 * __v_389); + let __v_423: G = G::from_u64(4294967296); + let __v_424: G = (__v_423 * __v_390); + let __v_425: G = G::from_u64(1099511627776); + let __v_426: G = (__v_425 * __v_391); + let __v_427: G = G::from_u64(281474976710656); + let __v_428: G = (__v_427 * __v_392); + let __v_429: G = G::from_u64(72057594037927936); + let __v_430: G = (__v_429 * __v_393); + let __v_431: G = (__v_428 + __v_430); + let __v_432: G = (__v_426 + __v_431); + let __v_433: G = (__v_424 + __v_432); + let __v_434: G = (__v_422 + __v_433); + let __v_435: G = (__v_420 + __v_434); + let __v_436: G = (__v_418 + __v_435); + let __v_437: G = (__v_386 + __v_436); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __v_438: G = __r_arr[0]; + let __v_439: G = __r_arr[1]; let __v_440: G = G::from_u64(1); - let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_442: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_441: G = G::from_u64(1); + let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_22, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_443: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_443, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_439, __v_443]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_444: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_444, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_444, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_445: G = __r_arr[0]; - let __v_446: G = __r_arr[1]; - let __v_447: G = (__v_365 + __v_0); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; - let __v_448: G = __r_arr[0]; - let __v_449: G = G::from_u64(1); - if (__v_448 != __v_449) { - return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_449.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_450: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_446: G = __r_arr[0]; + let __v_447: G = __r_arr[1]; + let __v_448: G = (__v_366 + __v_0); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_449: G = __r_arr[0]; + let __v_450: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_451: G = __r_arr[0]; - let __v_452: G = (__v_450 - __v_451); - let __v_453: G = G::from_bool((__v_452 == G::ZERO)); - let __v_454: G = G::from_u64(1); - if (__v_453 != __v_454) { - return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_452: G = __r_arr[0]; + let __v_453: G = G::from_u64(0); + if (__v_1 != __v_453) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_453.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_455: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_454: G = G::from_u64(0); + if (__v_2 != __v_454) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None }); + } + let __v_455: G = G::from_u64(1); + if (__v_3 != __v_455) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; - let __v_457: G = (__v_455 - __v_456); - let __v_458: G = G::from_bool((__v_457 == G::ZERO)); - let __v_459: G = G::from_u64(1); - if (__v_458 != __v_459) { - return Err(ExecError::AssertEqMismatch { lhs: __v_458.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: None }); + let __v_457: G = G::from_u64(1); + if (__v_456 != __v_457) { + return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_460: G = __r_arr[0]; - let __v_461: G = (__v_460 - __v_365); - let __v_462: G = G::from_bool((__v_461 == G::ZERO)); - let __v_463: G = G::from_u64(1); - if (__v_462 != __v_463) { - return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_463.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_458: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_459: G = __r_arr[0]; + let __v_460: G = (__v_458 - __v_459); + let __v_461: G = G::from_bool((__v_460 == G::ZERO)); + let __v_462: G = G::from_u64(1); + if (__v_461 != __v_462) { + return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_463: G = __r_arr[0]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; - let __v_465: G = (__v_464 - __v_4); + let __v_465: G = (__v_463 - __v_464); let __v_466: G = G::from_bool((__v_465 == G::ZERO)); let __v_467: G = G::from_u64(1); if (__v_466 != __v_467) { return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_468: G = __r_arr[0]; - let __v_469: G = G::from_u64(1); - if (__v_468 != __v_469) { - return Err(ExecError::AssertEqMismatch { lhs: __v_468.as_canonical_u64(), rhs: __v_469.as_canonical_u64(), msg: None }); + let __v_469: G = (__v_468 - __v_366); + let __v_470: G = G::from_bool((__v_469 == G::ZERO)); + let __v_471: G = G::from_u64(1); + if (__v_470 != __v_471) { + return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_472: G = __r_arr[0]; + let __v_473: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_474: G = __r_arr[0]; + let __v_475: G = (__v_473 + __v_474); + if (__v_472 != __v_475) { + return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_476: G = __r_arr[0]; + let __v_477: G = (__v_476 - __v_366); + let __v_478: G = G::from_bool((__v_477 == G::ZERO)); + let __v_479: G = G::from_u64(1); + if (__v_478 != __v_479) { + return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None }); } - let __v_470: G = G::from_u64(33); - let __v_471: G = { let __a_val = __v_447.as_canonical_u64(); let __b_val = __v_470.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __v_472: G = G::from_u64(1); - if (__v_471 != __v_472) { - return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_472.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_480: G = __r_arr[0]; + let __v_481: G = G::from_u64(1); + if (__v_480 != __v_481) { + return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; - let __v_473: G = __r_arr[0]; - let __ret: [G; OUT_183] = [__v_473]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_482: G = G::from_u64(33); + let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_484: G = G::from_u64(1); + if (__v_483 != __v_484) { + return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_485: G = __r_arr[0]; + let __v_486: G = G::from_u64(1); + if (__v_485 != __v_486) { + return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); + } + let __v_487: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_488: G = __r_arr[0]; + let __ret: [G; OUT_195] = [__v_488]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -17876,15 +18793,15 @@ fn aiur_fn_183( }) } -const INPUT_SIZE_184: usize = 1; -const IN_184: usize = 1; -const OUT_184: usize = 1; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_196: usize = 1; +const IN_196: usize = 1; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -17894,8 +18811,8 @@ fn aiur_fn_184( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_4]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_4]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -17906,10 +18823,10 @@ fn aiur_fn_184( if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_184] = [__v_8]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_8]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17919,15 +18836,15 @@ fn aiur_fn_184( }) } -const INPUT_SIZE_185: usize = 2; -const IN_185: usize = 2; -const OUT_185: usize = 1; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_197: usize = 2; +const IN_197: usize = 2; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17945,8 +18862,8 @@ fn aiur_fn_185( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_12]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_12]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -17958,19 +18875,19 @@ fn aiur_fn_185( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_185] = [__v_13]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_13]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_15]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_15]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -17987,15 +18904,15 @@ fn aiur_fn_185( }) } -const INPUT_SIZE_186: usize = 2; -const IN_186: usize = 2; -const OUT_186: usize = 1; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_198: usize = 2; +const IN_198: usize = 2; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18009,8 +18926,8 @@ fn aiur_fn_186( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_8]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_8]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -18022,19 +18939,19 @@ fn aiur_fn_186( 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_9]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_9]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_11]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_11]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18051,38 +18968,38 @@ fn aiur_fn_186( }) } -const INPUT_SIZE_187: usize = 1; -const IN_187: usize = 1; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_199: usize = 1; +const IN_199: usize = 1; +const OUT_199: usize = 2; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_188: usize = 2; -const IN_188: usize = 2; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_200: usize = 2; +const IN_200: usize = 2; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18091,64 +19008,64 @@ fn aiur_fn_188( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_189] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_190: usize = 2; -const IN_190: usize = 2; -const OUT_190: usize = 2; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_202: usize = 2; +const IN_202: usize = 2; +const OUT_202: usize = 2; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18157,12 +19074,12 @@ fn aiur_fn_190( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -18174,28 +19091,28 @@ fn aiur_fn_190( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_16, __v_14]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_16, __v_14]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 16; -const IN_191: usize = 16; -const OUT_191: usize = 0; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_203: usize = 16; +const IN_203: usize = 16; +const OUT_203: usize = 0; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18218,961 +19135,1002 @@ fn aiur_fn_191( let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_47, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; - let __v_50: G = __r_arr[2]; - let __v_51: G = __r_arr[3]; - let __v_52: G = __r_arr[4]; - let __v_53: G = __r_arr[5]; - let __v_54: G = __r_arr[6]; - let __v_55: G = __r_arr[7]; - let __v_56: G = __r_arr[8]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; - let __v_59: G = __r_arr[0]; - let __v_60: G = __r_arr[1]; - let __v_61: G = __r_arr[2]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_62: G = __r_arr[0]; - let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_64: G = __r_arr[0]; - let __v_65: G = __r_arr[1]; - let __v_66: G = G::from_u64(1); - let __v_67: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_67]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_68: G = __io_pair.0; - let __v_69: G = __io_pair.1; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_51]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = __r_arr[1]; + let __v_54: G = __r_arr[2]; + let __v_55: G = __r_arr[3]; + let __v_56: G = __r_arr[4]; + let __v_57: G = __r_arr[5]; + let __v_58: G = __r_arr[6]; + let __v_59: G = __r_arr[7]; + let __v_60: G = __r_arr[8]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = __r_arr[1]; + let __v_65: G = __r_arr[2]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(1); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_70, __v_68, __v_69]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; - let __v_71: G = __r_arr[0]; - let __v_72: G = G::from_u64(103); - let __v_73: G = G::from_u64(230); - let __v_74: G = G::from_u64(9); - let __v_75: G = G::from_u64(106); - let __v_76: G = G::from_u64(133); - let __v_77: G = G::from_u64(174); - let __v_78: G = G::from_u64(103); - let __v_79: G = G::from_u64(187); - let __v_80: G = G::from_u64(114); - let __v_81: G = G::from_u64(243); - let __v_82: G = G::from_u64(110); - let __v_83: G = G::from_u64(60); - let __v_84: G = G::from_u64(58); - let __v_85: G = G::from_u64(245); - let __v_86: G = G::from_u64(79); - let __v_87: G = G::from_u64(165); - let __v_88: G = G::from_u64(127); - let __v_89: G = G::from_u64(82); - let __v_90: G = G::from_u64(14); - let __v_91: G = G::from_u64(81); - let __v_92: G = G::from_u64(140); - let __v_93: G = G::from_u64(104); - let __v_94: G = G::from_u64(5); - let __v_95: G = G::from_u64(155); - let __v_96: G = G::from_u64(171); - let __v_97: G = G::from_u64(217); - let __v_98: G = G::from_u64(131); - let __v_99: G = G::from_u64(31); - let __v_100: G = G::from_u64(25); - let __v_101: G = G::from_u64(205); - let __v_102: G = G::from_u64(224); - let __v_103: G = G::from_u64(91); - let __v_104: G = G::from_u64(1); - let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_107: G = G::from_u64(0); - let __v_108: G = G::from_u64(0); - let __v_109: G = G::from_u64(0); - let __v_110: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_71]; let __info = io_buffer.get_info(__v_70, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_72: G = __io_pair.0; + let __v_73: G = __io_pair.1; + let __v_74: G = G::from_u64(1); + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_72, __v_73]; let __cu = true; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = G::from_u64(103); + let __v_77: G = G::from_u64(230); + let __v_78: G = G::from_u64(9); + let __v_79: G = G::from_u64(106); + let __v_80: G = G::from_u64(133); + let __v_81: G = G::from_u64(174); + let __v_82: G = G::from_u64(103); + let __v_83: G = G::from_u64(187); + let __v_84: G = G::from_u64(114); + let __v_85: G = G::from_u64(243); + let __v_86: G = G::from_u64(110); + let __v_87: G = G::from_u64(60); + let __v_88: G = G::from_u64(58); + let __v_89: G = G::from_u64(245); + let __v_90: G = G::from_u64(79); + let __v_91: G = G::from_u64(165); + let __v_92: G = G::from_u64(127); + let __v_93: G = G::from_u64(82); + let __v_94: G = G::from_u64(14); + let __v_95: G = G::from_u64(81); + let __v_96: G = G::from_u64(140); + let __v_97: G = G::from_u64(104); + let __v_98: G = G::from_u64(5); + let __v_99: G = G::from_u64(155); + let __v_100: G = G::from_u64(171); + let __v_101: G = G::from_u64(217); + let __v_102: G = G::from_u64(131); + let __v_103: G = G::from_u64(31); + let __v_104: G = G::from_u64(25); + let __v_105: G = G::from_u64(205); + let __v_106: G = G::from_u64(224); + let __v_107: G = G::from_u64(91); + let __v_108: G = G::from_u64(1); + let __v_109: G = G::from_u64(1); + let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_111: G = G::from_u64(0); let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); - let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_118: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_119: G = G::from_u64(1); - let __v_120: G = G::from_u64(1); - let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; - let __v_122: G = __r_arr[0]; - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; - let __v_123: G = __r_arr[0]; - let __v_124: G = __r_arr[1]; - let __v_125: G = __r_arr[2]; - let __v_126: G = __r_arr[3]; - let __v_127: G = __r_arr[4]; - let __v_128: G = __r_arr[5]; - let __v_129: G = __r_arr[6]; - let __v_130: G = __r_arr[7]; - let __v_131: G = __r_arr[8]; - let __v_132: G = __r_arr[9]; - let __v_133: G = __r_arr[10]; - let __v_134: G = __r_arr[11]; - let __v_135: G = __r_arr[12]; - let __v_136: G = __r_arr[13]; - let __v_137: G = __r_arr[14]; - let __v_138: G = __r_arr[15]; - let __v_139: G = __r_arr[16]; - let __v_140: G = __r_arr[17]; - let __v_141: G = __r_arr[18]; - let __v_142: G = __r_arr[19]; - let __v_143: G = __r_arr[20]; - let __v_144: G = __r_arr[21]; - let __v_145: G = __r_arr[22]; - let __v_146: G = __r_arr[23]; - let __v_147: G = __r_arr[24]; - let __v_148: G = __r_arr[25]; - let __v_149: G = __r_arr[26]; - let __v_150: G = __r_arr[27]; - let __v_151: G = __r_arr[28]; - let __v_152: G = __r_arr[29]; - let __v_153: G = __r_arr[30]; - let __v_154: G = __r_arr[31]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_155: G = __r_arr[0]; - let __v_156: G = __r_arr[1]; - let __v_157: G = __r_arr[2]; - let __v_158: G = __r_arr[3]; - let __v_159: G = __r_arr[4]; - let __v_160: G = __r_arr[5]; - let __v_161: G = __r_arr[6]; - let __v_162: G = __r_arr[7]; - let __v_163: G = __r_arr[8]; - let __v_164: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_165: G = __r_arr[0]; - let __v_166: G = __r_arr[1]; - let __v_167: G = __r_arr[2]; - let __v_168: G = __r_arr[3]; - let __v_169: G = __r_arr[4]; - let __v_170: G = __r_arr[5]; - let __v_171: G = __r_arr[6]; - let __v_172: G = __r_arr[7]; - let __v_173: G = __r_arr[8]; - let __v_174: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_175: G = __r_arr[0]; - let __v_176: G = __r_arr[1]; - let __v_177: G = __r_arr[2]; - let __v_178: G = __r_arr[3]; - let __v_179: G = __r_arr[4]; - let __v_180: G = __r_arr[5]; - let __v_181: G = __r_arr[6]; - let __v_182: G = __r_arr[7]; - let __v_183: G = __r_arr[8]; - let __v_184: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_185: G = __r_arr[0]; - let __v_186: G = __r_arr[1]; - let __v_187: G = __r_arr[2]; - let __v_188: G = __r_arr[3]; - let __v_189: G = __r_arr[4]; - let __v_190: G = __r_arr[5]; - let __v_191: G = __r_arr[6]; - let __v_192: G = __r_arr[7]; - let __v_193: G = __r_arr[8]; - let __v_194: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_195: G = __r_arr[0]; - let __v_196: G = __r_arr[1]; - let __v_197: G = __r_arr[2]; - let __v_198: G = __r_arr[3]; - let __v_199: G = __r_arr[4]; - let __v_200: G = __r_arr[5]; - let __v_201: G = __r_arr[6]; - let __v_202: G = __r_arr[7]; - let __v_203: G = __r_arr[8]; - let __v_204: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_205: G = __r_arr[0]; - let __v_206: G = __r_arr[1]; - let __v_207: G = __r_arr[2]; - let __v_208: G = __r_arr[3]; - let __v_209: G = __r_arr[4]; - let __v_210: G = __r_arr[5]; - let __v_211: G = __r_arr[6]; - let __v_212: G = __r_arr[7]; - let __v_213: G = __r_arr[8]; - let __v_214: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_215: G = __r_arr[0]; - let __v_216: G = __r_arr[1]; - let __v_217: G = __r_arr[2]; - let __v_218: G = __r_arr[3]; - let __v_219: G = __r_arr[4]; - let __v_220: G = __r_arr[5]; - let __v_221: G = __r_arr[6]; - let __v_222: G = __r_arr[7]; - let __v_223: G = __r_arr[8]; - let __v_224: G = __r_arr[9]; - let __v_225: G = G::from_u64(0); - let __v_226: G = G::from_u64(0); - let __v_227: G = G::from_u64(0); - let __v_228: G = G::from_u64(0); + let __v_117: G = G::from_u64(0); + let __v_118: G = G::from_u64(0); + let __v_119: G = G::from_u64(0); + let __v_120: G = G::from_u64(0); + let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_122: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_123: G = G::from_u64(1); + let __v_124: G = G::from_u64(1); + let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_126: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_126]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __v_127: G = __r_arr[0]; + let __v_128: G = __r_arr[1]; + let __v_129: G = __r_arr[2]; + let __v_130: G = __r_arr[3]; + let __v_131: G = __r_arr[4]; + let __v_132: G = __r_arr[5]; + let __v_133: G = __r_arr[6]; + let __v_134: G = __r_arr[7]; + let __v_135: G = __r_arr[8]; + let __v_136: G = __r_arr[9]; + let __v_137: G = __r_arr[10]; + let __v_138: G = __r_arr[11]; + let __v_139: G = __r_arr[12]; + let __v_140: G = __r_arr[13]; + let __v_141: G = __r_arr[14]; + let __v_142: G = __r_arr[15]; + let __v_143: G = __r_arr[16]; + let __v_144: G = __r_arr[17]; + let __v_145: G = __r_arr[18]; + let __v_146: G = __r_arr[19]; + let __v_147: G = __r_arr[20]; + let __v_148: G = __r_arr[21]; + let __v_149: G = __r_arr[22]; + let __v_150: G = __r_arr[23]; + let __v_151: G = __r_arr[24]; + let __v_152: G = __r_arr[25]; + let __v_153: G = __r_arr[26]; + let __v_154: G = __r_arr[27]; + let __v_155: G = __r_arr[28]; + let __v_156: G = __r_arr[29]; + let __v_157: G = __r_arr[30]; + let __v_158: G = __r_arr[31]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_159: G = __r_arr[0]; + let __v_160: G = __r_arr[1]; + let __v_161: G = __r_arr[2]; + let __v_162: G = __r_arr[3]; + let __v_163: G = __r_arr[4]; + let __v_164: G = __r_arr[5]; + let __v_165: G = __r_arr[6]; + let __v_166: G = __r_arr[7]; + let __v_167: G = __r_arr[8]; + let __v_168: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_168]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_169: G = __r_arr[0]; + let __v_170: G = __r_arr[1]; + let __v_171: G = __r_arr[2]; + let __v_172: G = __r_arr[3]; + let __v_173: G = __r_arr[4]; + let __v_174: G = __r_arr[5]; + let __v_175: G = __r_arr[6]; + let __v_176: G = __r_arr[7]; + let __v_177: G = __r_arr[8]; + let __v_178: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_178]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_179: G = __r_arr[0]; + let __v_180: G = __r_arr[1]; + let __v_181: G = __r_arr[2]; + let __v_182: G = __r_arr[3]; + let __v_183: G = __r_arr[4]; + let __v_184: G = __r_arr[5]; + let __v_185: G = __r_arr[6]; + let __v_186: G = __r_arr[7]; + let __v_187: G = __r_arr[8]; + let __v_188: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_189: G = __r_arr[0]; + let __v_190: G = __r_arr[1]; + let __v_191: G = __r_arr[2]; + let __v_192: G = __r_arr[3]; + let __v_193: G = __r_arr[4]; + let __v_194: G = __r_arr[5]; + let __v_195: G = __r_arr[6]; + let __v_196: G = __r_arr[7]; + let __v_197: G = __r_arr[8]; + let __v_198: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_198]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_199: G = __r_arr[0]; + let __v_200: G = __r_arr[1]; + let __v_201: G = __r_arr[2]; + let __v_202: G = __r_arr[3]; + let __v_203: G = __r_arr[4]; + let __v_204: G = __r_arr[5]; + let __v_205: G = __r_arr[6]; + let __v_206: G = __r_arr[7]; + let __v_207: G = __r_arr[8]; + let __v_208: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_208]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_209: G = __r_arr[0]; + let __v_210: G = __r_arr[1]; + let __v_211: G = __r_arr[2]; + let __v_212: G = __r_arr[3]; + let __v_213: G = __r_arr[4]; + let __v_214: G = __r_arr[5]; + let __v_215: G = __r_arr[6]; + let __v_216: G = __r_arr[7]; + let __v_217: G = __r_arr[8]; + let __v_218: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_218]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_219: G = __r_arr[0]; + let __v_220: G = __r_arr[1]; + let __v_221: G = __r_arr[2]; + let __v_222: G = __r_arr[3]; + let __v_223: G = __r_arr[4]; + let __v_224: G = __r_arr[5]; + let __v_225: G = __r_arr[6]; + let __v_226: G = __r_arr[7]; + let __v_227: G = __r_arr[8]; + let __v_228: G = __r_arr[9]; let __v_229: G = G::from_u64(0); let __v_230: G = G::from_u64(0); let __v_231: G = G::from_u64(0); - let __v_232: G = G::from_u64(1); - let __v_233: G = G::from_u64(1); - let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_242: G = __r_arr[0]; - let __v_243: G = __r_arr[1]; - let __v_244: G = __r_arr[2]; - let __v_245: G = __r_arr[3]; - let __v_246: G = __r_arr[4]; - let __v_247: G = __r_arr[5]; - let __v_248: G = __r_arr[6]; - let __v_249: G = __r_arr[7]; - let __v_250: G = __r_arr[8]; - let __v_251: G = __r_arr[9]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; - let __v_252: G = __r_arr[0]; - let __v_253: G = __r_arr[1]; - let __v_254: G = __r_arr[2]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; - let __v_255: G = __r_arr[0]; - let __v_256: G = __r_arr[1]; - let __v_257: G = __r_arr[2]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; - let __v_258: G = __r_arr[0]; - let __v_259: G = __r_arr[1]; - let __v_260: G = G::from_u64(0); - let __v_261: G = { let __values: [G; 10] = [__v_260, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_253]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_232: G = G::from_u64(0); + let __v_233: G = G::from_u64(0); + let __v_234: G = G::from_u64(0); + let __v_235: G = G::from_u64(0); + let __v_236: G = G::from_u64(1); + let __v_237: G = G::from_u64(1); + let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_240: G = { let __values: [G; 10] = [__v_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_241: G = { let __values: [G; 10] = [__v_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_245: G = { let __values: [G; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_246: G = __r_arr[0]; + let __v_247: G = __r_arr[1]; + let __v_248: G = __r_arr[2]; + let __v_249: G = __r_arr[3]; + let __v_250: G = __r_arr[4]; + let __v_251: G = __r_arr[5]; + let __v_252: G = __r_arr[6]; + let __v_253: G = __r_arr[7]; + let __v_254: G = __r_arr[8]; + let __v_255: G = __r_arr[9]; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_255, __v_246]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __v_256: G = __r_arr[0]; + let __v_257: G = __r_arr[1]; + let __v_258: G = __r_arr[2]; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_258]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __v_259: G = __r_arr[0]; + let __v_260: G = __r_arr[1]; + let __v_261: G = __r_arr[2]; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_261, __v_246]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; - let __v_263: G = G::from_u64(2); + let __v_263: G = __r_arr[1]; let __v_264: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_264]; let __info = io_buffer.get_info(__v_263, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_265: G = __io_pair.0; - let __v_266: G = __io_pair.1; + let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_245, __v_265]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_266: G = __r_arr[0]; let __v_267: G = G::from_u64(2); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_267, __v_265, __v_266]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; - let __v_268: G = __r_arr[0]; - let __v_269: G = G::from_u64(103); - let __v_270: G = G::from_u64(230); - let __v_271: G = G::from_u64(9); - let __v_272: G = G::from_u64(106); - let __v_273: G = G::from_u64(133); - let __v_274: G = G::from_u64(174); - let __v_275: G = G::from_u64(103); - let __v_276: G = G::from_u64(187); - let __v_277: G = G::from_u64(114); - let __v_278: G = G::from_u64(243); - let __v_279: G = G::from_u64(110); - let __v_280: G = G::from_u64(60); - let __v_281: G = G::from_u64(58); - let __v_282: G = G::from_u64(245); - let __v_283: G = G::from_u64(79); - let __v_284: G = G::from_u64(165); - let __v_285: G = G::from_u64(127); - let __v_286: G = G::from_u64(82); - let __v_287: G = G::from_u64(14); - let __v_288: G = G::from_u64(81); - let __v_289: G = G::from_u64(140); - let __v_290: G = G::from_u64(104); - let __v_291: G = G::from_u64(5); - let __v_292: G = G::from_u64(155); - let __v_293: G = G::from_u64(171); - let __v_294: G = G::from_u64(217); - let __v_295: G = G::from_u64(131); - let __v_296: G = G::from_u64(31); - let __v_297: G = G::from_u64(25); - let __v_298: G = G::from_u64(205); - let __v_299: G = G::from_u64(224); - let __v_300: G = G::from_u64(91); - let __v_301: G = G::from_u64(1); - let __v_302: G = G::from_u64(1); - let __v_303: G = { let __values: [G; 3] = [__v_301, __v_302, __v_302]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_304: G = G::from_u64(0); - let __v_305: G = G::from_u64(0); - let __v_306: G = G::from_u64(0); - let __v_307: G = G::from_u64(0); + let __v_268: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_268]; let __info = io_buffer.get_info(__v_267, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_269: G = __io_pair.0; + let __v_270: G = __io_pair.1; + let __v_271: G = G::from_u64(2); + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_271, __v_269, __v_270]; let __cu = true; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_272: G = __r_arr[0]; + let __v_273: G = G::from_u64(103); + let __v_274: G = G::from_u64(230); + let __v_275: G = G::from_u64(9); + let __v_276: G = G::from_u64(106); + let __v_277: G = G::from_u64(133); + let __v_278: G = G::from_u64(174); + let __v_279: G = G::from_u64(103); + let __v_280: G = G::from_u64(187); + let __v_281: G = G::from_u64(114); + let __v_282: G = G::from_u64(243); + let __v_283: G = G::from_u64(110); + let __v_284: G = G::from_u64(60); + let __v_285: G = G::from_u64(58); + let __v_286: G = G::from_u64(245); + let __v_287: G = G::from_u64(79); + let __v_288: G = G::from_u64(165); + let __v_289: G = G::from_u64(127); + let __v_290: G = G::from_u64(82); + let __v_291: G = G::from_u64(14); + let __v_292: G = G::from_u64(81); + let __v_293: G = G::from_u64(140); + let __v_294: G = G::from_u64(104); + let __v_295: G = G::from_u64(5); + let __v_296: G = G::from_u64(155); + let __v_297: G = G::from_u64(171); + let __v_298: G = G::from_u64(217); + let __v_299: G = G::from_u64(131); + let __v_300: G = G::from_u64(31); + let __v_301: G = G::from_u64(25); + let __v_302: G = G::from_u64(205); + let __v_303: G = G::from_u64(224); + let __v_304: G = G::from_u64(91); + let __v_305: G = G::from_u64(1); + let __v_306: G = G::from_u64(1); + let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_308: G = G::from_u64(0); let __v_309: G = G::from_u64(0); let __v_310: G = G::from_u64(0); let __v_311: G = G::from_u64(0); let __v_312: G = G::from_u64(0); let __v_313: G = G::from_u64(0); - let __v_314: G = { let __values: [G; 8] = [__v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_315: G = { let __values: [G; 32] = [__v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_316: G = G::from_u64(1); - let __v_317: G = G::from_u64(1); - let __v_318: G = { let __values: [G; 34] = [__v_316, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; - let __v_319: G = __r_arr[0]; - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_319]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; - let __v_320: G = __r_arr[0]; - let __v_321: G = __r_arr[1]; - let __v_322: G = __r_arr[2]; - let __v_323: G = __r_arr[3]; - let __v_324: G = __r_arr[4]; - let __v_325: G = __r_arr[5]; - let __v_326: G = __r_arr[6]; - let __v_327: G = __r_arr[7]; - let __v_328: G = __r_arr[8]; - let __v_329: G = __r_arr[9]; - let __v_330: G = __r_arr[10]; - let __v_331: G = __r_arr[11]; - let __v_332: G = __r_arr[12]; - let __v_333: G = __r_arr[13]; - let __v_334: G = __r_arr[14]; - let __v_335: G = __r_arr[15]; - let __v_336: G = __r_arr[16]; - let __v_337: G = __r_arr[17]; - let __v_338: G = __r_arr[18]; - let __v_339: G = __r_arr[19]; - let __v_340: G = __r_arr[20]; - let __v_341: G = __r_arr[21]; - let __v_342: G = __r_arr[22]; - let __v_343: G = __r_arr[23]; - let __v_344: G = __r_arr[24]; - let __v_345: G = __r_arr[25]; - let __v_346: G = __r_arr[26]; - let __v_347: G = __r_arr[27]; - let __v_348: G = __r_arr[28]; - let __v_349: G = __r_arr[29]; - let __v_350: G = __r_arr[30]; - let __v_351: G = __r_arr[31]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; - let __v_352: G = __r_arr[0]; - let __v_353: G = __r_arr[1]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_353, __v_352]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; - let __v_354: G = __r_arr[0]; - let __v_355: G = __r_arr[1]; + let __v_314: G = G::from_u64(0); + let __v_315: G = G::from_u64(0); + let __v_316: G = G::from_u64(0); + let __v_317: G = G::from_u64(0); + let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_319: G = { let __values: [G; 32] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_320: G = G::from_u64(1); + let __v_321: G = G::from_u64(1); + let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_323: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_323]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __v_324: G = __r_arr[0]; + let __v_325: G = __r_arr[1]; + let __v_326: G = __r_arr[2]; + let __v_327: G = __r_arr[3]; + let __v_328: G = __r_arr[4]; + let __v_329: G = __r_arr[5]; + let __v_330: G = __r_arr[6]; + let __v_331: G = __r_arr[7]; + let __v_332: G = __r_arr[8]; + let __v_333: G = __r_arr[9]; + let __v_334: G = __r_arr[10]; + let __v_335: G = __r_arr[11]; + let __v_336: G = __r_arr[12]; + let __v_337: G = __r_arr[13]; + let __v_338: G = __r_arr[14]; + let __v_339: G = __r_arr[15]; + let __v_340: G = __r_arr[16]; + let __v_341: G = __r_arr[17]; + let __v_342: G = __r_arr[18]; + let __v_343: G = __r_arr[19]; + let __v_344: G = __r_arr[20]; + let __v_345: G = __r_arr[21]; + let __v_346: G = __r_arr[22]; + let __v_347: G = __r_arr[23]; + let __v_348: G = __r_arr[24]; + let __v_349: G = __r_arr[25]; + let __v_350: G = __r_arr[26]; + let __v_351: G = __r_arr[27]; + let __v_352: G = __r_arr[28]; + let __v_353: G = __r_arr[29]; + let __v_354: G = __r_arr[30]; + let __v_355: G = __r_arr[31]; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_356: G = __r_arr[0]; + let __v_357: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_357, __v_356]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_358: G = __r_arr[0]; + let __v_359: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_356: G = __r_arr[0]; - let __v_357: G = G::from_bool((__v_356 == G::ZERO)); - let __v_358: G = G::from_u64(0); - if (__v_357 != __v_358) { - return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_360: G = __r_arr[0]; + let __v_361: G = G::from_bool((__v_360 == G::ZERO)); + let __v_362: G = G::from_u64(0); + if (__v_361 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_359: G = __r_arr[0]; - if (__v_359 != __v_356) { - return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_363: G = __r_arr[0]; + if (__v_363 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - if (__v_360 != __v_356) { - return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_364: G = __r_arr[0]; + if (__v_364 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_361: G = __r_arr[0]; - if (__v_361 != __v_356) { - return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_365: G = __r_arr[0]; + if (__v_365 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; - let __v_362: G = __r_arr[0]; - let __v_363: G = G::from_u64(1); - if (__v_362 != __v_363) { - return Err(ExecError::AssertEqMismatch { lhs: __v_362.as_canonical_u64(), rhs: __v_363.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_366: G = __r_arr[0]; + let __v_367: G = G::from_u64(1); + if (__v_366 != __v_367) { + return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_367.as_canonical_u64(), msg: None }); } - let __v_364: G = G::from_u64(1); - break '__mc_0 [__v_364]; + let __v_368: G = G::from_u64(1); + break '__mc_0 [__v_368]; }, } }; - let __v_356: G = __mc_out___mc_0[0]; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() { + let __v_360: G = __mc_out___mc_0[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() { _ => { - match __v_155.as_canonical_u64() { + match __v_159.as_canonical_u64() { _ => { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_357: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; - let __v_358: G = __r_arr[0]; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_256, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_361: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_262, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_362: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { - let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() { + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() { 0u64 => { - let __v_359: G = G::from_u64(1); - let __v_360: G = G::from_u64(1); - let __v_361: G = { let __values: [G; 3] = [__v_359, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - break '__mc_2 [__v_361]; + let __v_363: G = G::from_u64(1); + let __v_364: G = G::from_u64(1); + let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_365]; }, 1u64 => { - break '__mc_2 [__v_256]; + break '__mc_2 [__v_260]; }, _ => { - return Err(ExecError::MatchNoCase(__v_255.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_259.as_canonical_u64())); }, } }; - let __v_359: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; - let __v_361: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; - let __v_362: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_363: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_363: G = __mc_out___mc_2[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_34, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __v_365: G = G::from_u64(0); - let __v_366: G = G::from_u64(109); - let __v_367: G = G::from_u64(0); - let __v_368: G = G::from_u64(117); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_365: G = __r_arr[0]; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_366: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_367: G = __r_arr[0]; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_266, __v_367]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_368: G = __r_arr[0]; let __v_369: G = G::from_u64(0); - let __v_370: G = G::from_u64(108); + let __v_370: G = G::from_u64(109); let __v_371: G = G::from_u64(0); - let __v_372: G = G::from_u64(116); + let __v_372: G = G::from_u64(117); let __v_373: G = G::from_u64(0); - let __v_374: G = G::from_u64(105); + let __v_374: G = G::from_u64(108); let __v_375: G = G::from_u64(0); - let __v_376: G = G::from_u64(45); + let __v_376: G = G::from_u64(116); let __v_377: G = G::from_u64(0); - let __v_378: G = G::from_u64(115); + let __v_378: G = G::from_u64(105); let __v_379: G = G::from_u64(0); - let __v_380: G = G::from_u64(116); + let __v_380: G = G::from_u64(45); let __v_381: G = G::from_u64(0); - let __v_382: G = G::from_u64(97); + let __v_382: G = G::from_u64(115); let __v_383: G = G::from_u64(0); - let __v_384: G = G::from_u64(114); + let __v_384: G = G::from_u64(116); let __v_385: G = G::from_u64(0); - let __v_386: G = G::from_u64(107); + let __v_386: G = G::from_u64(97); let __v_387: G = G::from_u64(0); - let __v_388: G = G::from_u64(47); + let __v_388: G = G::from_u64(114); let __v_389: G = G::from_u64(0); - let __v_390: G = G::from_u64(118); + let __v_390: G = G::from_u64(107); let __v_391: G = G::from_u64(0); - let __v_392: G = G::from_u64(48); - let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_407: G = G::from_u64(1); - let __v_408: G = G::from_u64(1); - let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_410: G = __r_arr[0]; - let __v_411: G = __r_arr[1]; - let __v_412: G = __r_arr[2]; - let __v_413: G = __r_arr[3]; - let __v_414: G = __r_arr[4]; - let __v_415: G = __r_arr[5]; - let __v_416: G = __r_arr[6]; - let __v_417: G = __r_arr[7]; - let __v_418: G = __r_arr[8]; - let __v_419: G = __r_arr[9]; - let __v_420: G = __r_arr[10]; - let __v_421: G = __r_arr[11]; - let __v_422: G = __r_arr[12]; - let __v_423: G = __r_arr[13]; - let __v_424: G = __r_arr[14]; - let __v_425: G = __r_arr[15]; - let __v_426: G = __r_arr[16]; - let __v_427: G = __r_arr[17]; - let __v_428: G = G::from_u64(1); - let __v_429: G = G::from_u64(1); - let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_431: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_432: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_433: G = __r_arr[0]; - let __v_434: G = G::from_u64(1); - let __v_435: G = G::from_u64(1); - let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_392: G = G::from_u64(47); + let __v_393: G = G::from_u64(0); + let __v_394: G = G::from_u64(118); + let __v_395: G = G::from_u64(0); + let __v_396: G = G::from_u64(48); + let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_398: G = { let __values: [G; 3] = [__v_393, __v_394, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_399: G = { let __values: [G; 3] = [__v_391, __v_392, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_400: G = { let __values: [G; 3] = [__v_389, __v_390, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_401: G = { let __values: [G; 3] = [__v_387, __v_388, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_402: G = { let __values: [G; 3] = [__v_385, __v_386, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_403: G = { let __values: [G; 3] = [__v_383, __v_384, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_404: G = { let __values: [G; 3] = [__v_381, __v_382, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_405: G = { let __values: [G; 3] = [__v_379, __v_380, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_406: G = { let __values: [G; 3] = [__v_377, __v_378, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_407: G = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_411: G = G::from_u64(1); + let __v_412: G = G::from_u64(1); + let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_410, __v_413]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_414: G = __r_arr[0]; + let __v_415: G = __r_arr[1]; + let __v_416: G = __r_arr[2]; + let __v_417: G = __r_arr[3]; + let __v_418: G = __r_arr[4]; + let __v_419: G = __r_arr[5]; + let __v_420: G = __r_arr[6]; + let __v_421: G = __r_arr[7]; + let __v_422: G = __r_arr[8]; + let __v_423: G = __r_arr[9]; + let __v_424: G = __r_arr[10]; + let __v_425: G = __r_arr[11]; + let __v_426: G = __r_arr[12]; + let __v_427: G = __r_arr[13]; + let __v_428: G = __r_arr[14]; + let __v_429: G = __r_arr[15]; + let __v_430: G = __r_arr[16]; + let __v_431: G = __r_arr[17]; + let __v_432: G = G::from_u64(1); + let __v_433: G = G::from_u64(1); + let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_435: G = __r_arr[0]; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_436: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_430, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_437: G = __r_arr[0]; - let __v_438: G = __r_arr[1]; - let __v_439: G = __r_arr[2]; - let __v_440: G = __r_arr[3]; - let __v_441: G = __r_arr[4]; - let __v_442: G = __r_arr[5]; - let __v_443: G = __r_arr[6]; - let __v_444: G = __r_arr[7]; - let __v_445: G = __r_arr[8]; - let __v_446: G = __r_arr[9]; - let __v_447: G = __r_arr[10]; - let __v_448: G = __r_arr[11]; - let __v_449: G = __r_arr[12]; - let __v_450: G = __r_arr[13]; - let __v_451: G = __r_arr[14]; - let __v_452: G = __r_arr[15]; - let __v_453: G = __r_arr[16]; - let __v_454: G = __r_arr[17]; - let __v_455: G = G::from_u64(1); - let __v_456: G = G::from_u64(1); - let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_458: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_459: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_460: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; - let __v_461: G = __r_arr[0]; - let __v_462: G = G::from_u64(1); - let __v_463: G = G::from_u64(1); - let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_437, __v_440]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_441: G = __r_arr[0]; + let __v_442: G = __r_arr[1]; + let __v_443: G = __r_arr[2]; + let __v_444: G = __r_arr[3]; + let __v_445: G = __r_arr[4]; + let __v_446: G = __r_arr[5]; + let __v_447: G = __r_arr[6]; + let __v_448: G = __r_arr[7]; + let __v_449: G = __r_arr[8]; + let __v_450: G = __r_arr[9]; + let __v_451: G = __r_arr[10]; + let __v_452: G = __r_arr[11]; + let __v_453: G = __r_arr[12]; + let __v_454: G = __r_arr[13]; + let __v_455: G = __r_arr[14]; + let __v_456: G = __r_arr[15]; + let __v_457: G = __r_arr[16]; + let __v_458: G = __r_arr[17]; + let __v_459: G = G::from_u64(1); + let __v_460: G = G::from_u64(1); + let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_462: G = __r_arr[0]; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_463: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_457, __v_463]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_464: G = __r_arr[0]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_464, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_465: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_466: G = __r_arr[0]; + let __v_466: G = G::from_u64(1); let __v_467: G = G::from_u64(1); - let __v_468: G = G::from_u64(1); - let __v_469: G = { let __values: [G; 3] = [__v_467, __v_468, __v_468]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_466, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_30, __v_468]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_469: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_465, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_470: G = __r_arr[0]; - let __v_471: G = __r_arr[1]; - let __v_472: G = __r_arr[2]; - let __v_473: G = __r_arr[3]; - let __v_474: G = __r_arr[4]; - let __v_475: G = __r_arr[5]; - let __v_476: G = __r_arr[6]; - let __v_477: G = __r_arr[7]; - let __v_478: G = __r_arr[8]; - let __v_479: G = __r_arr[9]; - let __v_480: G = __r_arr[10]; - let __v_481: G = __r_arr[11]; - let __v_482: G = __r_arr[12]; - let __v_483: G = __r_arr[13]; - let __v_484: G = __r_arr[14]; - let __v_485: G = __r_arr[15]; - let __v_486: G = __r_arr[16]; - let __v_487: G = __r_arr[17]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_486, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; - let __v_488: G = __r_arr[0]; - let __v_489: G = G::from_u64(1); - let __v_490: G = G::from_u64(1); - let __v_491: G = { let __values: [G; 3] = [__v_489, __v_490, __v_490]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_488, __v_491]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_471: G = G::from_u64(1); + let __v_472: G = G::from_u64(1); + let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_470, __v_473]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_474: G = __r_arr[0]; + let __v_475: G = __r_arr[1]; + let __v_476: G = __r_arr[2]; + let __v_477: G = __r_arr[3]; + let __v_478: G = __r_arr[4]; + let __v_479: G = __r_arr[5]; + let __v_480: G = __r_arr[6]; + let __v_481: G = __r_arr[7]; + let __v_482: G = __r_arr[8]; + let __v_483: G = __r_arr[9]; + let __v_484: G = __r_arr[10]; + let __v_485: G = __r_arr[11]; + let __v_486: G = __r_arr[12]; + let __v_487: G = __r_arr[13]; + let __v_488: G = __r_arr[14]; + let __v_489: G = __r_arr[15]; + let __v_490: G = __r_arr[16]; + let __v_491: G = __r_arr[17]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_490, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; - let __v_493: G = __r_arr[1]; - let __v_494: G = __r_arr[2]; - let __v_495: G = __r_arr[3]; - let __v_496: G = __r_arr[4]; - let __v_497: G = __r_arr[5]; - let __v_498: G = __r_arr[6]; - let __v_499: G = __r_arr[7]; - let __v_500: G = __r_arr[8]; - let __v_501: G = __r_arr[9]; - let __v_502: G = __r_arr[10]; - let __v_503: G = __r_arr[11]; - let __v_504: G = __r_arr[12]; - let __v_505: G = __r_arr[13]; - let __v_506: G = __r_arr[14]; - let __v_507: G = __r_arr[15]; - let __v_508: G = __r_arr[16]; - let __v_509: G = __r_arr[17]; - let __v_510: G = G::from_u64(256); - let __v_511: G = (__v_510 * __v_411); - let __v_512: G = G::from_u64(65536); - let __v_513: G = (__v_512 * __v_412); - let __v_514: G = G::from_u64(16777216); - let __v_515: G = (__v_514 * __v_413); - let __v_516: G = G::from_u64(4294967296); - let __v_517: G = (__v_516 * __v_414); - let __v_518: G = G::from_u64(1099511627776); - let __v_519: G = (__v_518 * __v_415); - let __v_520: G = G::from_u64(281474976710656); - let __v_521: G = (__v_520 * __v_416); - let __v_522: G = G::from_u64(72057594037927936); - let __v_523: G = (__v_522 * __v_417); - let __v_524: G = (__v_521 + __v_523); - let __v_525: G = (__v_519 + __v_524); - let __v_526: G = (__v_517 + __v_525); - let __v_527: G = (__v_515 + __v_526); - let __v_528: G = (__v_513 + __v_527); - let __v_529: G = (__v_511 + __v_528); - let __v_530: G = (__v_410 + __v_529); - let __v_531: G = G::from_u64(256); - let __v_532: G = (__v_531 * __v_419); - let __v_533: G = G::from_u64(65536); - let __v_534: G = (__v_533 * __v_420); - let __v_535: G = G::from_u64(16777216); - let __v_536: G = (__v_535 * __v_421); - let __v_537: G = G::from_u64(4294967296); - let __v_538: G = (__v_537 * __v_422); - let __v_539: G = G::from_u64(1099511627776); - let __v_540: G = (__v_539 * __v_423); - let __v_541: G = G::from_u64(281474976710656); - let __v_542: G = (__v_541 * __v_424); - let __v_543: G = G::from_u64(72057594037927936); - let __v_544: G = (__v_543 * __v_425); - let __v_545: G = (__v_542 + __v_544); - let __v_546: G = (__v_540 + __v_545); - let __v_547: G = (__v_538 + __v_546); - let __v_548: G = (__v_536 + __v_547); - let __v_549: G = (__v_534 + __v_548); - let __v_550: G = (__v_532 + __v_549); - let __v_551: G = (__v_418 + __v_550); - let __v_552: G = G::from_u64(256); - let __v_553: G = (__v_552 * __v_438); - let __v_554: G = G::from_u64(65536); - let __v_555: G = (__v_554 * __v_439); - let __v_556: G = G::from_u64(16777216); - let __v_557: G = (__v_556 * __v_440); - let __v_558: G = G::from_u64(4294967296); - let __v_559: G = (__v_558 * __v_441); - let __v_560: G = G::from_u64(1099511627776); - let __v_561: G = (__v_560 * __v_442); - let __v_562: G = G::from_u64(281474976710656); - let __v_563: G = (__v_562 * __v_443); - let __v_564: G = G::from_u64(72057594037927936); - let __v_565: G = (__v_564 * __v_444); - let __v_566: G = (__v_563 + __v_565); - let __v_567: G = (__v_561 + __v_566); - let __v_568: G = (__v_559 + __v_567); - let __v_569: G = (__v_557 + __v_568); - let __v_570: G = (__v_555 + __v_569); - let __v_571: G = (__v_553 + __v_570); - let __v_572: G = (__v_437 + __v_571); - let __v_573: G = G::from_u64(256); - let __v_574: G = (__v_573 * __v_446); - let __v_575: G = G::from_u64(65536); - let __v_576: G = (__v_575 * __v_447); - let __v_577: G = G::from_u64(16777216); - let __v_578: G = (__v_577 * __v_448); - let __v_579: G = G::from_u64(4294967296); - let __v_580: G = (__v_579 * __v_449); - let __v_581: G = G::from_u64(1099511627776); - let __v_582: G = (__v_581 * __v_450); - let __v_583: G = G::from_u64(281474976710656); - let __v_584: G = (__v_583 * __v_451); - let __v_585: G = G::from_u64(72057594037927936); - let __v_586: G = (__v_585 * __v_452); - let __v_587: G = (__v_584 + __v_586); - let __v_588: G = (__v_582 + __v_587); - let __v_589: G = (__v_580 + __v_588); - let __v_590: G = (__v_578 + __v_589); - let __v_591: G = (__v_576 + __v_590); - let __v_592: G = (__v_574 + __v_591); - let __v_593: G = (__v_445 + __v_592); - let __v_594: G = G::from_u64(256); - let __v_595: G = (__v_594 * __v_471); - let __v_596: G = G::from_u64(65536); - let __v_597: G = (__v_596 * __v_472); - let __v_598: G = G::from_u64(16777216); - let __v_599: G = (__v_598 * __v_473); - let __v_600: G = G::from_u64(4294967296); - let __v_601: G = (__v_600 * __v_474); - let __v_602: G = G::from_u64(1099511627776); - let __v_603: G = (__v_602 * __v_475); - let __v_604: G = G::from_u64(281474976710656); - let __v_605: G = (__v_604 * __v_476); - let __v_606: G = G::from_u64(72057594037927936); - let __v_607: G = (__v_606 * __v_477); - let __v_608: G = (__v_605 + __v_607); - let __v_609: G = (__v_603 + __v_608); - let __v_610: G = (__v_601 + __v_609); - let __v_611: G = (__v_599 + __v_610); - let __v_612: G = (__v_597 + __v_611); - let __v_613: G = (__v_595 + __v_612); - let __v_614: G = (__v_470 + __v_613); - let __v_615: G = G::from_u64(256); - let __v_616: G = (__v_615 * __v_479); - let __v_617: G = G::from_u64(65536); - let __v_618: G = (__v_617 * __v_480); - let __v_619: G = G::from_u64(16777216); - let __v_620: G = (__v_619 * __v_481); - let __v_621: G = G::from_u64(4294967296); - let __v_622: G = (__v_621 * __v_482); - let __v_623: G = G::from_u64(1099511627776); - let __v_624: G = (__v_623 * __v_483); - let __v_625: G = G::from_u64(281474976710656); - let __v_626: G = (__v_625 * __v_484); - let __v_627: G = G::from_u64(72057594037927936); - let __v_628: G = (__v_627 * __v_485); - let __v_629: G = (__v_626 + __v_628); - let __v_630: G = (__v_624 + __v_629); - let __v_631: G = (__v_622 + __v_630); - let __v_632: G = (__v_620 + __v_631); - let __v_633: G = (__v_618 + __v_632); - let __v_634: G = (__v_616 + __v_633); - let __v_635: G = (__v_478 + __v_634); - let __v_636: G = G::from_u64(256); - let __v_637: G = (__v_636 * __v_493); - let __v_638: G = G::from_u64(65536); - let __v_639: G = (__v_638 * __v_494); - let __v_640: G = G::from_u64(16777216); - let __v_641: G = (__v_640 * __v_495); - let __v_642: G = G::from_u64(4294967296); - let __v_643: G = (__v_642 * __v_496); - let __v_644: G = G::from_u64(1099511627776); - let __v_645: G = (__v_644 * __v_497); - let __v_646: G = G::from_u64(281474976710656); - let __v_647: G = (__v_646 * __v_498); - let __v_648: G = G::from_u64(72057594037927936); - let __v_649: G = (__v_648 * __v_499); - let __v_650: G = (__v_647 + __v_649); - let __v_651: G = (__v_645 + __v_650); - let __v_652: G = (__v_643 + __v_651); - let __v_653: G = (__v_641 + __v_652); - let __v_654: G = (__v_639 + __v_653); - let __v_655: G = (__v_637 + __v_654); - let __v_656: G = (__v_492 + __v_655); - let __v_657: G = G::from_u64(256); - let __v_658: G = (__v_657 * __v_501); - let __v_659: G = G::from_u64(65536); - let __v_660: G = (__v_659 * __v_502); - let __v_661: G = G::from_u64(16777216); - let __v_662: G = (__v_661 * __v_503); - let __v_663: G = G::from_u64(4294967296); - let __v_664: G = (__v_663 * __v_504); - let __v_665: G = G::from_u64(1099511627776); - let __v_666: G = (__v_665 * __v_505); - let __v_667: G = G::from_u64(281474976710656); - let __v_668: G = (__v_667 * __v_506); - let __v_669: G = G::from_u64(72057594037927936); - let __v_670: G = (__v_669 * __v_507); - let __v_671: G = (__v_668 + __v_670); - let __v_672: G = (__v_666 + __v_671); - let __v_673: G = (__v_664 + __v_672); - let __v_674: G = (__v_662 + __v_673); - let __v_675: G = (__v_660 + __v_674); - let __v_676: G = (__v_658 + __v_675); - let __v_677: G = (__v_500 + __v_676); - let __v_678: G = G::from_u64(0); - let __v_679: G = G::from_u64(0); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; - let __v_680: G = __r_arr[0]; - let __v_681: G = __r_arr[1]; + let __v_493: G = G::from_u64(1); + let __v_494: G = G::from_u64(1); + let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_492, __v_495]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_496: G = __r_arr[0]; + let __v_497: G = __r_arr[1]; + let __v_498: G = __r_arr[2]; + let __v_499: G = __r_arr[3]; + let __v_500: G = __r_arr[4]; + let __v_501: G = __r_arr[5]; + let __v_502: G = __r_arr[6]; + let __v_503: G = __r_arr[7]; + let __v_504: G = __r_arr[8]; + let __v_505: G = __r_arr[9]; + let __v_506: G = __r_arr[10]; + let __v_507: G = __r_arr[11]; + let __v_508: G = __r_arr[12]; + let __v_509: G = __r_arr[13]; + let __v_510: G = __r_arr[14]; + let __v_511: G = __r_arr[15]; + let __v_512: G = __r_arr[16]; + let __v_513: G = __r_arr[17]; + let __v_514: G = G::from_u64(256); + let __v_515: G = (__v_514 * __v_415); + let __v_516: G = G::from_u64(65536); + let __v_517: G = (__v_516 * __v_416); + let __v_518: G = G::from_u64(16777216); + let __v_519: G = (__v_518 * __v_417); + let __v_520: G = G::from_u64(4294967296); + let __v_521: G = (__v_520 * __v_418); + let __v_522: G = G::from_u64(1099511627776); + let __v_523: G = (__v_522 * __v_419); + let __v_524: G = G::from_u64(281474976710656); + let __v_525: G = (__v_524 * __v_420); + let __v_526: G = G::from_u64(72057594037927936); + let __v_527: G = (__v_526 * __v_421); + let __v_528: G = (__v_525 + __v_527); + let __v_529: G = (__v_523 + __v_528); + let __v_530: G = (__v_521 + __v_529); + let __v_531: G = (__v_519 + __v_530); + let __v_532: G = (__v_517 + __v_531); + let __v_533: G = (__v_515 + __v_532); + let __v_534: G = (__v_414 + __v_533); + let __v_535: G = G::from_u64(256); + let __v_536: G = (__v_535 * __v_423); + let __v_537: G = G::from_u64(65536); + let __v_538: G = (__v_537 * __v_424); + let __v_539: G = G::from_u64(16777216); + let __v_540: G = (__v_539 * __v_425); + let __v_541: G = G::from_u64(4294967296); + let __v_542: G = (__v_541 * __v_426); + let __v_543: G = G::from_u64(1099511627776); + let __v_544: G = (__v_543 * __v_427); + let __v_545: G = G::from_u64(281474976710656); + let __v_546: G = (__v_545 * __v_428); + let __v_547: G = G::from_u64(72057594037927936); + let __v_548: G = (__v_547 * __v_429); + let __v_549: G = (__v_546 + __v_548); + let __v_550: G = (__v_544 + __v_549); + let __v_551: G = (__v_542 + __v_550); + let __v_552: G = (__v_540 + __v_551); + let __v_553: G = (__v_538 + __v_552); + let __v_554: G = (__v_536 + __v_553); + let __v_555: G = (__v_422 + __v_554); + let __v_556: G = G::from_u64(256); + let __v_557: G = (__v_556 * __v_442); + let __v_558: G = G::from_u64(65536); + let __v_559: G = (__v_558 * __v_443); + let __v_560: G = G::from_u64(16777216); + let __v_561: G = (__v_560 * __v_444); + let __v_562: G = G::from_u64(4294967296); + let __v_563: G = (__v_562 * __v_445); + let __v_564: G = G::from_u64(1099511627776); + let __v_565: G = (__v_564 * __v_446); + let __v_566: G = G::from_u64(281474976710656); + let __v_567: G = (__v_566 * __v_447); + let __v_568: G = G::from_u64(72057594037927936); + let __v_569: G = (__v_568 * __v_448); + let __v_570: G = (__v_567 + __v_569); + let __v_571: G = (__v_565 + __v_570); + let __v_572: G = (__v_563 + __v_571); + let __v_573: G = (__v_561 + __v_572); + let __v_574: G = (__v_559 + __v_573); + let __v_575: G = (__v_557 + __v_574); + let __v_576: G = (__v_441 + __v_575); + let __v_577: G = G::from_u64(256); + let __v_578: G = (__v_577 * __v_450); + let __v_579: G = G::from_u64(65536); + let __v_580: G = (__v_579 * __v_451); + let __v_581: G = G::from_u64(16777216); + let __v_582: G = (__v_581 * __v_452); + let __v_583: G = G::from_u64(4294967296); + let __v_584: G = (__v_583 * __v_453); + let __v_585: G = G::from_u64(1099511627776); + let __v_586: G = (__v_585 * __v_454); + let __v_587: G = G::from_u64(281474976710656); + let __v_588: G = (__v_587 * __v_455); + let __v_589: G = G::from_u64(72057594037927936); + let __v_590: G = (__v_589 * __v_456); + let __v_591: G = (__v_588 + __v_590); + let __v_592: G = (__v_586 + __v_591); + let __v_593: G = (__v_584 + __v_592); + let __v_594: G = (__v_582 + __v_593); + let __v_595: G = (__v_580 + __v_594); + let __v_596: G = (__v_578 + __v_595); + let __v_597: G = (__v_449 + __v_596); + let __v_598: G = G::from_u64(256); + let __v_599: G = (__v_598 * __v_475); + let __v_600: G = G::from_u64(65536); + let __v_601: G = (__v_600 * __v_476); + let __v_602: G = G::from_u64(16777216); + let __v_603: G = (__v_602 * __v_477); + let __v_604: G = G::from_u64(4294967296); + let __v_605: G = (__v_604 * __v_478); + let __v_606: G = G::from_u64(1099511627776); + let __v_607: G = (__v_606 * __v_479); + let __v_608: G = G::from_u64(281474976710656); + let __v_609: G = (__v_608 * __v_480); + let __v_610: G = G::from_u64(72057594037927936); + let __v_611: G = (__v_610 * __v_481); + let __v_612: G = (__v_609 + __v_611); + let __v_613: G = (__v_607 + __v_612); + let __v_614: G = (__v_605 + __v_613); + let __v_615: G = (__v_603 + __v_614); + let __v_616: G = (__v_601 + __v_615); + let __v_617: G = (__v_599 + __v_616); + let __v_618: G = (__v_474 + __v_617); + let __v_619: G = G::from_u64(256); + let __v_620: G = (__v_619 * __v_483); + let __v_621: G = G::from_u64(65536); + let __v_622: G = (__v_621 * __v_484); + let __v_623: G = G::from_u64(16777216); + let __v_624: G = (__v_623 * __v_485); + let __v_625: G = G::from_u64(4294967296); + let __v_626: G = (__v_625 * __v_486); + let __v_627: G = G::from_u64(1099511627776); + let __v_628: G = (__v_627 * __v_487); + let __v_629: G = G::from_u64(281474976710656); + let __v_630: G = (__v_629 * __v_488); + let __v_631: G = G::from_u64(72057594037927936); + let __v_632: G = (__v_631 * __v_489); + let __v_633: G = (__v_630 + __v_632); + let __v_634: G = (__v_628 + __v_633); + let __v_635: G = (__v_626 + __v_634); + let __v_636: G = (__v_624 + __v_635); + let __v_637: G = (__v_622 + __v_636); + let __v_638: G = (__v_620 + __v_637); + let __v_639: G = (__v_482 + __v_638); + let __v_640: G = G::from_u64(256); + let __v_641: G = (__v_640 * __v_497); + let __v_642: G = G::from_u64(65536); + let __v_643: G = (__v_642 * __v_498); + let __v_644: G = G::from_u64(16777216); + let __v_645: G = (__v_644 * __v_499); + let __v_646: G = G::from_u64(4294967296); + let __v_647: G = (__v_646 * __v_500); + let __v_648: G = G::from_u64(1099511627776); + let __v_649: G = (__v_648 * __v_501); + let __v_650: G = G::from_u64(281474976710656); + let __v_651: G = (__v_650 * __v_502); + let __v_652: G = G::from_u64(72057594037927936); + let __v_653: G = (__v_652 * __v_503); + let __v_654: G = (__v_651 + __v_653); + let __v_655: G = (__v_649 + __v_654); + let __v_656: G = (__v_647 + __v_655); + let __v_657: G = (__v_645 + __v_656); + let __v_658: G = (__v_643 + __v_657); + let __v_659: G = (__v_641 + __v_658); + let __v_660: G = (__v_496 + __v_659); + let __v_661: G = G::from_u64(256); + let __v_662: G = (__v_661 * __v_505); + let __v_663: G = G::from_u64(65536); + let __v_664: G = (__v_663 * __v_506); + let __v_665: G = G::from_u64(16777216); + let __v_666: G = (__v_665 * __v_507); + let __v_667: G = G::from_u64(4294967296); + let __v_668: G = (__v_667 * __v_508); + let __v_669: G = G::from_u64(1099511627776); + let __v_670: G = (__v_669 * __v_509); + let __v_671: G = G::from_u64(281474976710656); + let __v_672: G = (__v_671 * __v_510); + let __v_673: G = G::from_u64(72057594037927936); + let __v_674: G = (__v_673 * __v_511); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_668 + __v_676); + let __v_678: G = (__v_666 + __v_677); + let __v_679: G = (__v_664 + __v_678); + let __v_680: G = (__v_662 + __v_679); + let __v_681: G = (__v_504 + __v_680); let __v_682: G = G::from_u64(0); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_357, __v_358, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_682, __v_680, __v_681, __v_530, __v_551, __v_572, __v_593, __v_614, __v_635, __v_656, __v_677]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; - let __v_683: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_683: G = G::from_u64(0); + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_684: G = __r_arr[0]; + let __v_685: G = __r_arr[1]; + let __v_686: G = G::from_u64(0); + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __v_687: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_688: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_685: G = __r_arr[0]; - let __v_686: G = G::from_u64(1); - let __v_687: G = G::from_u64(1); - let __v_688: G = { let __values: [G; 3] = [__v_686, __v_687, __v_687]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_59.as_canonical_u64() { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_689: G = __r_arr[0]; + let __v_690: G = G::from_u64(1); + let __v_691: G = G::from_u64(1); + let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_63.as_canonical_u64() { 0u64 => { - break '__mc_3 [__v_688]; + break '__mc_3 [__v_692]; }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_60, __v_688]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_689: G = __r_arr[0]; - break '__mc_3 [__v_689]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_64, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_693: G = __r_arr[0]; + break '__mc_3 [__v_693]; }, _ => { - return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }; - let __v_689: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_690: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_691: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_692: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_693: G = __r_arr[0]; - let __v_694: G = G::from_u64(1); - let __v_695: G = G::from_u64(1); - let __v_696: G = { let __values: [G; 3] = [__v_694, __v_695, __v_695]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_693: G = __mc_out___mc_3[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_61, __v_693]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_694: G = __r_arr[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_68, __v_694]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_695: G = __r_arr[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_66, __v_695]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_696: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_512, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_697: G = __r_arr[0]; - let __v_698: G = __r_arr[1]; - let __v_699: G = __r_arr[2]; - let __v_700: G = __r_arr[3]; - let __v_701: G = __r_arr[4]; - let __v_702: G = __r_arr[5]; - let __v_703: G = __r_arr[6]; - let __v_704: G = __r_arr[7]; - let __v_705: G = __r_arr[8]; - let __v_706: G = __r_arr[9]; - let __v_707: G = __r_arr[10]; - let __v_708: G = __r_arr[11]; - let __v_709: G = __r_arr[12]; - let __v_710: G = __r_arr[13]; - let __v_711: G = __r_arr[14]; - let __v_712: G = __r_arr[15]; - let __v_713: G = __r_arr[16]; - let __v_714: G = __r_arr[17]; - let __v_715: G = G::from_u64(256); - let __v_716: G = (__v_715 * __v_698); - let __v_717: G = G::from_u64(65536); - let __v_718: G = (__v_717 * __v_699); - let __v_719: G = G::from_u64(16777216); - let __v_720: G = (__v_719 * __v_700); - let __v_721: G = G::from_u64(4294967296); - let __v_722: G = (__v_721 * __v_701); - let __v_723: G = G::from_u64(1099511627776); - let __v_724: G = (__v_723 * __v_702); - let __v_725: G = G::from_u64(281474976710656); - let __v_726: G = (__v_725 * __v_703); - let __v_727: G = G::from_u64(72057594037927936); - let __v_728: G = (__v_727 * __v_704); - let __v_729: G = (__v_726 + __v_728); - let __v_730: G = (__v_724 + __v_729); - let __v_731: G = (__v_722 + __v_730); - let __v_732: G = (__v_720 + __v_731); - let __v_733: G = (__v_718 + __v_732); - let __v_734: G = (__v_716 + __v_733); - let __v_735: G = (__v_697 + __v_734); - let __v_736: G = G::from_u64(256); - let __v_737: G = (__v_736 * __v_706); - let __v_738: G = G::from_u64(65536); - let __v_739: G = (__v_738 * __v_707); - let __v_740: G = G::from_u64(16777216); - let __v_741: G = (__v_740 * __v_708); - let __v_742: G = G::from_u64(4294967296); - let __v_743: G = (__v_742 * __v_709); - let __v_744: G = G::from_u64(1099511627776); - let __v_745: G = (__v_744 * __v_710); - let __v_746: G = G::from_u64(281474976710656); - let __v_747: G = (__v_746 * __v_711); - let __v_748: G = G::from_u64(72057594037927936); - let __v_749: G = (__v_748 * __v_712); - let __v_750: G = (__v_747 + __v_749); - let __v_751: G = (__v_745 + __v_750); - let __v_752: G = (__v_743 + __v_751); - let __v_753: G = (__v_741 + __v_752); - let __v_754: G = (__v_739 + __v_753); - let __v_755: G = (__v_737 + __v_754); - let __v_756: G = (__v_705 + __v_755); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; - let __v_757: G = __r_arr[0]; - let __v_758: G = __r_arr[1]; - let __v_759: G = G::from_u64(1); - let __v_760: G = G::from_u64(1); - let __v_761: G = { let __values: [G; 3] = [__v_759, __v_760, __v_760]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_46, __v_761]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_762: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_763: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_763, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; - let __v_764: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_764, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; - let __v_765: G = __r_arr[0]; - let __v_766: G = __r_arr[1]; - let __v_767: G = (__v_685 + __v_155); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_698: G = G::from_u64(1); + let __v_699: G = G::from_u64(1); + let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_697, __v_700]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_701: G = __r_arr[0]; + let __v_702: G = __r_arr[1]; + let __v_703: G = __r_arr[2]; + let __v_704: G = __r_arr[3]; + let __v_705: G = __r_arr[4]; + let __v_706: G = __r_arr[5]; + let __v_707: G = __r_arr[6]; + let __v_708: G = __r_arr[7]; + let __v_709: G = __r_arr[8]; + let __v_710: G = __r_arr[9]; + let __v_711: G = __r_arr[10]; + let __v_712: G = __r_arr[11]; + let __v_713: G = __r_arr[12]; + let __v_714: G = __r_arr[13]; + let __v_715: G = __r_arr[14]; + let __v_716: G = __r_arr[15]; + let __v_717: G = __r_arr[16]; + let __v_718: G = __r_arr[17]; + let __v_719: G = G::from_u64(256); + let __v_720: G = (__v_719 * __v_702); + let __v_721: G = G::from_u64(65536); + let __v_722: G = (__v_721 * __v_703); + let __v_723: G = G::from_u64(16777216); + let __v_724: G = (__v_723 * __v_704); + let __v_725: G = G::from_u64(4294967296); + let __v_726: G = (__v_725 * __v_705); + let __v_727: G = G::from_u64(1099511627776); + let __v_728: G = (__v_727 * __v_706); + let __v_729: G = G::from_u64(281474976710656); + let __v_730: G = (__v_729 * __v_707); + let __v_731: G = G::from_u64(72057594037927936); + let __v_732: G = (__v_731 * __v_708); + let __v_733: G = (__v_730 + __v_732); + let __v_734: G = (__v_728 + __v_733); + let __v_735: G = (__v_726 + __v_734); + let __v_736: G = (__v_724 + __v_735); + let __v_737: G = (__v_722 + __v_736); + let __v_738: G = (__v_720 + __v_737); + let __v_739: G = (__v_701 + __v_738); + let __v_740: G = G::from_u64(256); + let __v_741: G = (__v_740 * __v_710); + let __v_742: G = G::from_u64(65536); + let __v_743: G = (__v_742 * __v_711); + let __v_744: G = G::from_u64(16777216); + let __v_745: G = (__v_744 * __v_712); + let __v_746: G = G::from_u64(4294967296); + let __v_747: G = (__v_746 * __v_713); + let __v_748: G = G::from_u64(1099511627776); + let __v_749: G = (__v_748 * __v_714); + let __v_750: G = G::from_u64(281474976710656); + let __v_751: G = (__v_750 * __v_715); + let __v_752: G = G::from_u64(72057594037927936); + let __v_753: G = (__v_752 * __v_716); + let __v_754: G = (__v_751 + __v_753); + let __v_755: G = (__v_749 + __v_754); + let __v_756: G = (__v_747 + __v_755); + let __v_757: G = (__v_745 + __v_756); + let __v_758: G = (__v_743 + __v_757); + let __v_759: G = (__v_741 + __v_758); + let __v_760: G = (__v_709 + __v_759); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __v_761: G = __r_arr[0]; + let __v_762: G = __r_arr[1]; + let __v_763: G = G::from_u64(1); + let __v_764: G = G::from_u64(1); + let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_50, __v_765]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_766: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_762, __v_766]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_767: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_767, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_768: G = __r_arr[0]; - let __v_769: G = G::from_u64(1); - if (__v_768 != __v_769) { - return Err(ExecError::AssertEqMismatch { lhs: __v_768.as_canonical_u64(), rhs: __v_769.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_769: G = __r_arr[0]; + let __v_770: G = __r_arr[1]; + let __v_771: G = (__v_689 + __v_159); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_772: G = __r_arr[0]; + let __v_773: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_774: G = __r_arr[0]; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_775: G = __r_arr[0]; + let __v_776: G = G::from_u64(0); + if (__v_169 != __v_776) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_776.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_770: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_252]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_771: G = __r_arr[0]; - let __v_772: G = (__v_770 - __v_771); - let __v_773: G = G::from_bool((__v_772 == G::ZERO)); - let __v_774: G = G::from_u64(1); - if (__v_773 != __v_774) { - return Err(ExecError::AssertEqMismatch { lhs: __v_773.as_canonical_u64(), rhs: __v_774.as_canonical_u64(), msg: None }); + let __v_777: G = G::from_u64(0); + if (__v_179 != __v_777) { + return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_777.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_775: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_776: G = __r_arr[0]; - let __v_777: G = (__v_775 - __v_776); - let __v_778: G = G::from_bool((__v_777 == G::ZERO)); - let __v_779: G = G::from_u64(1); - if (__v_778 != __v_779) { - return Err(ExecError::AssertEqMismatch { lhs: __v_778.as_canonical_u64(), rhs: __v_779.as_canonical_u64(), msg: None }); + let __v_778: G = G::from_u64(1); + if (__v_189 != __v_778) { + return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_779: G = __r_arr[0]; + let __v_780: G = G::from_u64(1); + if (__v_779 != __v_780) { + return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_781: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_256]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_782: G = __r_arr[0]; + let __v_783: G = (__v_781 - __v_782); + let __v_784: G = G::from_bool((__v_783 == G::ZERO)); + let __v_785: G = G::from_u64(1); + if (__v_784 != __v_785) { + return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_780: G = __r_arr[0]; - let __v_781: G = (__v_780 - __v_685); - let __v_782: G = G::from_bool((__v_781 == G::ZERO)); - let __v_783: G = G::from_u64(1); - if (__v_782 != __v_783) { - return Err(ExecError::AssertEqMismatch { lhs: __v_782.as_canonical_u64(), rhs: __v_783.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_786: G = __r_arr[0]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_787: G = __r_arr[0]; + let __v_788: G = (__v_786 - __v_787); + let __v_789: G = G::from_bool((__v_788 == G::ZERO)); + let __v_790: G = G::from_u64(1); + if (__v_789 != __v_790) { + return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_784: G = __r_arr[0]; - let __v_785: G = (__v_784 - __v_195); - let __v_786: G = G::from_bool((__v_785 == G::ZERO)); - let __v_787: G = G::from_u64(1); - if (__v_786 != __v_787) { - return Err(ExecError::AssertEqMismatch { lhs: __v_786.as_canonical_u64(), rhs: __v_787.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_791: G = __r_arr[0]; + let __v_792: G = (__v_791 - __v_689); + let __v_793: G = G::from_bool((__v_792 == G::ZERO)); + let __v_794: G = G::from_u64(1); + if (__v_793 != __v_794) { + return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_788: G = __r_arr[0]; - let __v_789: G = G::from_u64(1); - if (__v_788 != __v_789) { - return Err(ExecError::AssertEqMismatch { lhs: __v_788.as_canonical_u64(), rhs: __v_789.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_795: G = __r_arr[0]; + let __v_796: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_797: G = __r_arr[0]; + let __v_798: G = (__v_796 + __v_797); + if (__v_795 != __v_798) { + return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); } - let __v_790: G = G::from_u64(33); - let __v_791: G = { let __a_val = __v_767.as_canonical_u64(); let __b_val = __v_790.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __v_792: G = G::from_u64(1); - if (__v_791 != __v_792) { - return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_799: G = __r_arr[0]; + let __v_800: G = (__v_799 - __v_689); + let __v_801: G = G::from_bool((__v_800 == G::ZERO)); + let __v_802: G = G::from_u64(1); + if (__v_801 != __v_802) { + return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_765, __v_766, __v_44, __v_735, __v_756, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_359, __v_358, __v_34, __v_656, __v_677, __v_684, __v_155, __v_767, __v_757, __v_38, __v_46, __v_685]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; - let __v_793: G = __r_arr[0]; - break '__mc_1 [__v_793]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_803: G = __r_arr[0]; + let __v_804: G = G::from_u64(1); + if (__v_803 != __v_804) { + return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None }); + } + let __v_805: G = G::from_u64(33); + let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_807: G = G::from_u64(1); + if (__v_806 != __v_807) { + return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_808: G = __r_arr[0]; + let __v_809: G = G::from_u64(1); + if (__v_808 != __v_809) { + return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); + } + let __v_810: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_811: G = __r_arr[0]; + break '__mc_1 [__v_811]; }, } }, @@ -19184,260 +20142,260 @@ fn aiur_fn_191( }, } }; - let __v_357: G = __mc_out___mc_1[0]; - let __v_358: G = (__v_18 + __v_19); - if (__v_65 != __v_358) { - return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None }); + let __v_361: G = __mc_out___mc_1[0]; + let __v_362: G = (__v_18 + __v_19); + if (__v_69 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); } - let __v_359: G = G::from_u64(256); - let __v_360: G = (__v_359 * __v_124); - let __v_361: G = G::from_u64(65536); - let __v_362: G = (__v_361 * __v_125); - let __v_363: G = G::from_u64(16777216); - let __v_364: G = (__v_363 * __v_126); - let __v_365: G = (__v_362 + __v_364); - let __v_366: G = (__v_360 + __v_365); - let __v_367: G = (__v_123 + __v_366); - let __v_368: G = G::from_u64(256); - let __v_369: G = (__v_368 * __v_128); - let __v_370: G = G::from_u64(65536); - let __v_371: G = (__v_370 * __v_129); - let __v_372: G = G::from_u64(16777216); - let __v_373: G = (__v_372 * __v_130); - let __v_374: G = (__v_371 + __v_373); - let __v_375: G = (__v_369 + __v_374); - let __v_376: G = (__v_127 + __v_375); - let __v_377: G = G::from_u64(256); - let __v_378: G = (__v_377 * __v_132); - let __v_379: G = G::from_u64(65536); - let __v_380: G = (__v_379 * __v_133); - let __v_381: G = G::from_u64(16777216); - let __v_382: G = (__v_381 * __v_134); - let __v_383: G = (__v_380 + __v_382); - let __v_384: G = (__v_378 + __v_383); - let __v_385: G = (__v_131 + __v_384); - let __v_386: G = G::from_u64(256); - let __v_387: G = (__v_386 * __v_136); - let __v_388: G = G::from_u64(65536); - let __v_389: G = (__v_388 * __v_137); - let __v_390: G = G::from_u64(16777216); - let __v_391: G = (__v_390 * __v_138); - let __v_392: G = (__v_389 + __v_391); - let __v_393: G = (__v_387 + __v_392); - let __v_394: G = (__v_135 + __v_393); - let __v_395: G = G::from_u64(256); - let __v_396: G = (__v_395 * __v_140); - let __v_397: G = G::from_u64(65536); - let __v_398: G = (__v_397 * __v_141); - let __v_399: G = G::from_u64(16777216); - let __v_400: G = (__v_399 * __v_142); - let __v_401: G = (__v_398 + __v_400); - let __v_402: G = (__v_396 + __v_401); - let __v_403: G = (__v_139 + __v_402); - let __v_404: G = G::from_u64(256); - let __v_405: G = (__v_404 * __v_144); - let __v_406: G = G::from_u64(65536); - let __v_407: G = (__v_406 * __v_145); - let __v_408: G = G::from_u64(16777216); - let __v_409: G = (__v_408 * __v_146); - let __v_410: G = (__v_407 + __v_409); - let __v_411: G = (__v_405 + __v_410); - let __v_412: G = (__v_143 + __v_411); - let __v_413: G = G::from_u64(256); - let __v_414: G = (__v_413 * __v_148); - let __v_415: G = G::from_u64(65536); - let __v_416: G = (__v_415 * __v_149); - let __v_417: G = G::from_u64(16777216); - let __v_418: G = (__v_417 * __v_150); - let __v_419: G = (__v_416 + __v_418); - let __v_420: G = (__v_414 + __v_419); - let __v_421: G = (__v_147 + __v_420); - let __v_422: G = G::from_u64(256); - let __v_423: G = (__v_422 * __v_152); - let __v_424: G = G::from_u64(65536); - let __v_425: G = (__v_424 * __v_153); - let __v_426: G = G::from_u64(16777216); - let __v_427: G = (__v_426 * __v_154); - let __v_428: G = (__v_425 + __v_427); - let __v_429: G = (__v_423 + __v_428); - let __v_430: G = (__v_151 + __v_429); - if (__v_367 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); + let __v_363: G = G::from_u64(256); + let __v_364: G = (__v_363 * __v_128); + let __v_365: G = G::from_u64(65536); + let __v_366: G = (__v_365 * __v_129); + let __v_367: G = G::from_u64(16777216); + let __v_368: G = (__v_367 * __v_130); + let __v_369: G = (__v_366 + __v_368); + let __v_370: G = (__v_364 + __v_369); + let __v_371: G = (__v_127 + __v_370); + let __v_372: G = G::from_u64(256); + let __v_373: G = (__v_372 * __v_132); + let __v_374: G = G::from_u64(65536); + let __v_375: G = (__v_374 * __v_133); + let __v_376: G = G::from_u64(16777216); + let __v_377: G = (__v_376 * __v_134); + let __v_378: G = (__v_375 + __v_377); + let __v_379: G = (__v_373 + __v_378); + let __v_380: G = (__v_131 + __v_379); + let __v_381: G = G::from_u64(256); + let __v_382: G = (__v_381 * __v_136); + let __v_383: G = G::from_u64(65536); + let __v_384: G = (__v_383 * __v_137); + let __v_385: G = G::from_u64(16777216); + let __v_386: G = (__v_385 * __v_138); + let __v_387: G = (__v_384 + __v_386); + let __v_388: G = (__v_382 + __v_387); + let __v_389: G = (__v_135 + __v_388); + let __v_390: G = G::from_u64(256); + let __v_391: G = (__v_390 * __v_140); + let __v_392: G = G::from_u64(65536); + let __v_393: G = (__v_392 * __v_141); + let __v_394: G = G::from_u64(16777216); + let __v_395: G = (__v_394 * __v_142); + let __v_396: G = (__v_393 + __v_395); + let __v_397: G = (__v_391 + __v_396); + let __v_398: G = (__v_139 + __v_397); + let __v_399: G = G::from_u64(256); + let __v_400: G = (__v_399 * __v_144); + let __v_401: G = G::from_u64(65536); + let __v_402: G = (__v_401 * __v_145); + let __v_403: G = G::from_u64(16777216); + let __v_404: G = (__v_403 * __v_146); + let __v_405: G = (__v_402 + __v_404); + let __v_406: G = (__v_400 + __v_405); + let __v_407: G = (__v_143 + __v_406); + let __v_408: G = G::from_u64(256); + let __v_409: G = (__v_408 * __v_148); + let __v_410: G = G::from_u64(65536); + let __v_411: G = (__v_410 * __v_149); + let __v_412: G = G::from_u64(16777216); + let __v_413: G = (__v_412 * __v_150); + let __v_414: G = (__v_411 + __v_413); + let __v_415: G = (__v_409 + __v_414); + let __v_416: G = (__v_147 + __v_415); + let __v_417: G = G::from_u64(256); + let __v_418: G = (__v_417 * __v_152); + let __v_419: G = G::from_u64(65536); + let __v_420: G = (__v_419 * __v_153); + let __v_421: G = G::from_u64(16777216); + let __v_422: G = (__v_421 * __v_154); + let __v_423: G = (__v_420 + __v_422); + let __v_424: G = (__v_418 + __v_423); + let __v_425: G = (__v_151 + __v_424); + let __v_426: G = G::from_u64(256); + let __v_427: G = (__v_426 * __v_156); + let __v_428: G = G::from_u64(65536); + let __v_429: G = (__v_428 * __v_157); + let __v_430: G = G::from_u64(16777216); + let __v_431: G = (__v_430 * __v_158); + let __v_432: G = (__v_429 + __v_431); + let __v_433: G = (__v_427 + __v_432); + let __v_434: G = (__v_155 + __v_433); + if (__v_371 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); } - if (__v_376 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); + if (__v_380 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_380.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); } - if (__v_385 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_385.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); + if (__v_389 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_389.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } - if (__v_394 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); + if (__v_398 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); } - if (__v_403 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_403.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); + if (__v_407 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_407.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); } - if (__v_412 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); + if (__v_416 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_416.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); } - if (__v_421 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); + if (__v_425 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_425.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); } - if (__v_430 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_430.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); + if (__v_434 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_434.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_259.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_431: G = __loaded[0]; - let __v_432: G = __loaded[1]; - let __v_433: G = __loaded[2]; - let __v_434: G = G::from_u64(1); - let __v_435: G = G::from_u64(1); - if (__v_431 != __v_434) { - return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_434.as_canonical_u64(), msg: None }); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_435: G = __loaded[0]; + let __v_436: G = __loaded[1]; + let __v_437: G = __loaded[2]; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + if (__v_435 != __v_438) { + return Err(ExecError::AssertEqMismatch { lhs: __v_435.as_canonical_u64(), rhs: __v_438.as_canonical_u64(), msg: None }); } - if (__v_432 != __v_435) { - return Err(ExecError::AssertEqMismatch { lhs: __v_432.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None }); + if (__v_436 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_436.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); } - if (__v_433 != __v_435) { - return Err(ExecError::AssertEqMismatch { lhs: __v_433.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None }); + if (__v_437 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); } - let __v_436: G = G::from_u64(256); - let __v_437: G = (__v_436 * __v_321); - let __v_438: G = G::from_u64(65536); - let __v_439: G = (__v_438 * __v_322); - let __v_440: G = G::from_u64(16777216); - let __v_441: G = (__v_440 * __v_323); - let __v_442: G = (__v_439 + __v_441); - let __v_443: G = (__v_437 + __v_442); - let __v_444: G = (__v_320 + __v_443); - let __v_445: G = G::from_u64(256); - let __v_446: G = (__v_445 * __v_325); - let __v_447: G = G::from_u64(65536); - let __v_448: G = (__v_447 * __v_326); - let __v_449: G = G::from_u64(16777216); - let __v_450: G = (__v_449 * __v_327); - let __v_451: G = (__v_448 + __v_450); - let __v_452: G = (__v_446 + __v_451); - let __v_453: G = (__v_324 + __v_452); - let __v_454: G = G::from_u64(256); - let __v_455: G = (__v_454 * __v_329); - let __v_456: G = G::from_u64(65536); - let __v_457: G = (__v_456 * __v_330); - let __v_458: G = G::from_u64(16777216); - let __v_459: G = (__v_458 * __v_331); - let __v_460: G = (__v_457 + __v_459); - let __v_461: G = (__v_455 + __v_460); - let __v_462: G = (__v_328 + __v_461); - let __v_463: G = G::from_u64(256); - let __v_464: G = (__v_463 * __v_333); - let __v_465: G = G::from_u64(65536); - let __v_466: G = (__v_465 * __v_334); - let __v_467: G = G::from_u64(16777216); - let __v_468: G = (__v_467 * __v_335); - let __v_469: G = (__v_466 + __v_468); - let __v_470: G = (__v_464 + __v_469); - let __v_471: G = (__v_332 + __v_470); - let __v_472: G = G::from_u64(256); - let __v_473: G = (__v_472 * __v_337); - let __v_474: G = G::from_u64(65536); - let __v_475: G = (__v_474 * __v_338); - let __v_476: G = G::from_u64(16777216); - let __v_477: G = (__v_476 * __v_339); - let __v_478: G = (__v_475 + __v_477); - let __v_479: G = (__v_473 + __v_478); - let __v_480: G = (__v_336 + __v_479); - let __v_481: G = G::from_u64(256); - let __v_482: G = (__v_481 * __v_341); - let __v_483: G = G::from_u64(65536); - let __v_484: G = (__v_483 * __v_342); - let __v_485: G = G::from_u64(16777216); - let __v_486: G = (__v_485 * __v_343); - let __v_487: G = (__v_484 + __v_486); - let __v_488: G = (__v_482 + __v_487); - let __v_489: G = (__v_340 + __v_488); - let __v_490: G = G::from_u64(256); - let __v_491: G = (__v_490 * __v_345); - let __v_492: G = G::from_u64(65536); - let __v_493: G = (__v_492 * __v_346); - let __v_494: G = G::from_u64(16777216); - let __v_495: G = (__v_494 * __v_347); - let __v_496: G = (__v_493 + __v_495); - let __v_497: G = (__v_491 + __v_496); - let __v_498: G = (__v_344 + __v_497); - let __v_499: G = G::from_u64(256); - let __v_500: G = (__v_499 * __v_349); - let __v_501: G = G::from_u64(65536); - let __v_502: G = (__v_501 * __v_350); - let __v_503: G = G::from_u64(16777216); - let __v_504: G = (__v_503 * __v_351); - let __v_505: G = (__v_502 + __v_504); - let __v_506: G = (__v_500 + __v_505); - let __v_507: G = (__v_348 + __v_506); - if (__v_444 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); + let __v_440: G = G::from_u64(256); + let __v_441: G = (__v_440 * __v_325); + let __v_442: G = G::from_u64(65536); + let __v_443: G = (__v_442 * __v_326); + let __v_444: G = G::from_u64(16777216); + let __v_445: G = (__v_444 * __v_327); + let __v_446: G = (__v_443 + __v_445); + let __v_447: G = (__v_441 + __v_446); + let __v_448: G = (__v_324 + __v_447); + let __v_449: G = G::from_u64(256); + let __v_450: G = (__v_449 * __v_329); + let __v_451: G = G::from_u64(65536); + let __v_452: G = (__v_451 * __v_330); + let __v_453: G = G::from_u64(16777216); + let __v_454: G = (__v_453 * __v_331); + let __v_455: G = (__v_452 + __v_454); + let __v_456: G = (__v_450 + __v_455); + let __v_457: G = (__v_328 + __v_456); + let __v_458: G = G::from_u64(256); + let __v_459: G = (__v_458 * __v_333); + let __v_460: G = G::from_u64(65536); + let __v_461: G = (__v_460 * __v_334); + let __v_462: G = G::from_u64(16777216); + let __v_463: G = (__v_462 * __v_335); + let __v_464: G = (__v_461 + __v_463); + let __v_465: G = (__v_459 + __v_464); + let __v_466: G = (__v_332 + __v_465); + let __v_467: G = G::from_u64(256); + let __v_468: G = (__v_467 * __v_337); + let __v_469: G = G::from_u64(65536); + let __v_470: G = (__v_469 * __v_338); + let __v_471: G = G::from_u64(16777216); + let __v_472: G = (__v_471 * __v_339); + let __v_473: G = (__v_470 + __v_472); + let __v_474: G = (__v_468 + __v_473); + let __v_475: G = (__v_336 + __v_474); + let __v_476: G = G::from_u64(256); + let __v_477: G = (__v_476 * __v_341); + let __v_478: G = G::from_u64(65536); + let __v_479: G = (__v_478 * __v_342); + let __v_480: G = G::from_u64(16777216); + let __v_481: G = (__v_480 * __v_343); + let __v_482: G = (__v_479 + __v_481); + let __v_483: G = (__v_477 + __v_482); + let __v_484: G = (__v_340 + __v_483); + let __v_485: G = G::from_u64(256); + let __v_486: G = (__v_485 * __v_345); + let __v_487: G = G::from_u64(65536); + let __v_488: G = (__v_487 * __v_346); + let __v_489: G = G::from_u64(16777216); + let __v_490: G = (__v_489 * __v_347); + let __v_491: G = (__v_488 + __v_490); + let __v_492: G = (__v_486 + __v_491); + let __v_493: G = (__v_344 + __v_492); + let __v_494: G = G::from_u64(256); + let __v_495: G = (__v_494 * __v_349); + let __v_496: G = G::from_u64(65536); + let __v_497: G = (__v_496 * __v_350); + let __v_498: G = G::from_u64(16777216); + let __v_499: G = (__v_498 * __v_351); + let __v_500: G = (__v_497 + __v_499); + let __v_501: G = (__v_495 + __v_500); + let __v_502: G = (__v_348 + __v_501); + let __v_503: G = G::from_u64(256); + let __v_504: G = (__v_503 * __v_353); + let __v_505: G = G::from_u64(65536); + let __v_506: G = (__v_505 * __v_354); + let __v_507: G = G::from_u64(16777216); + let __v_508: G = (__v_507 * __v_355); + let __v_509: G = (__v_506 + __v_508); + let __v_510: G = (__v_504 + __v_509); + let __v_511: G = (__v_352 + __v_510); + if (__v_448 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } - if (__v_453 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); + if (__v_457 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_457.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } - if (__v_462 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); + if (__v_466 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } - if (__v_471 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); + if (__v_475 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_475.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } - if (__v_480 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); + if (__v_484 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } - if (__v_489 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); + if (__v_493 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } - if (__v_498 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); + if (__v_502 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } - if (__v_507 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); + if (__v_511 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_355.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_508: G = __loaded[0]; - let __v_509: G = __loaded[1]; - let __v_510: G = __loaded[2]; - let __v_511: G = G::from_u64(1); - let __v_512: G = G::from_u64(1); - if (__v_508 != __v_511) { - return Err(ExecError::AssertEqMismatch { lhs: __v_508.as_canonical_u64(), rhs: __v_511.as_canonical_u64(), msg: None }); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_512: G = __loaded[0]; + let __v_513: G = __loaded[1]; + let __v_514: G = __loaded[2]; + let __v_515: G = G::from_u64(1); + let __v_516: G = G::from_u64(1); + if (__v_512 != __v_515) { + return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None }); } - if (__v_509 != __v_512) { - return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None }); + if (__v_513 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); } - if (__v_510 != __v_512) { - return Err(ExecError::AssertEqMismatch { lhs: __v_510.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None }); + if (__v_514 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); } - let __v_513: G = G::from_u64(1); - if (__v_356 != __v_513) { - return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: None }); + let __v_517: G = G::from_u64(1); + if (__v_360 != __v_517) { + return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None }); } - let __v_514: G = G::from_u64(1); - if (__v_357 != __v_514) { - return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: None }); + let __v_518: G = G::from_u64(1); + if (__v_361 != __v_518) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_191] = []; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = []; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 2; -const IN_192: usize = 2; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_204: usize = 2; +const IN_204: usize = 2; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -19445,8 +20403,8 @@ fn aiur_fn_192( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_192] = [__v_4]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_4]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19456,15 +20414,15 @@ fn aiur_fn_192( }) } -const INPUT_SIZE_193: usize = 1; -const IN_193: usize = 1; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_205: usize = 1; +const IN_205: usize = 1; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -19473,87 +20431,18 @@ fn aiur_fn_193( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_193] = [__v_4]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_193] = [__v_4]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_194: usize = 2; -const IN_194: usize = 2; -const OUT_194: usize = 2; -fn aiur_fn_194( - inp: [G; IN_194], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - let __v_6: G = __loaded[3]; - match __v_3.as_canonical_u64() { - 0u64 => { - let __ret: [G; OUT_194] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_195: usize = 1; -const IN_195: usize = 1; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - let __v_4: G = __loaded[3]; - let __v_5: G = __loaded[4]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_195] = [__v_6]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_205] = [__v_4]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(1); - let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_195] = [__v_8]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_4 + __v_5); + let __ret: [G; OUT_205] = [__v_6]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19563,15 +20452,15 @@ fn aiur_fn_195( }) } -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_206: usize = 1; +const IN_206: usize = 1; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19581,81 +20470,36 @@ fn aiur_fn_196( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_196] = [__v_5]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = G::from_u64(1); - let __v_7: G = (__v_5 + __v_6); - let __ret: [G; OUT_196] = [__v_7]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_197: usize = 2; -const IN_197: usize = 2; -const OUT_197: usize = 1; -fn aiur_fn_197( - inp: [G; IN_197], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - let __v_5: G = __loaded[3]; - let __v_6: G = __loaded[4]; - let __v_7: G = __loaded[5]; - let __v_8: G = __loaded[6]; - let __v_9: G = __loaded[7]; - let __v_10: G = __loaded[8]; - let __v_11: G = __loaded[9]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_197] = [__v_1]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_206] = [__v_5]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_14]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_5 + __v_6); + let __ret: [G; OUT_206] = [__v_7]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_198: usize = 2; -const IN_198: usize = 2; -const OUT_198: usize = 1; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_207: usize = 2; +const IN_207: usize = 2; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19665,17 +20509,17 @@ fn aiur_fn_198( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_198] = [__v_1]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_1]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_7]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19685,57 +20529,56 @@ fn aiur_fn_198( }) } -const INPUT_SIZE_199: usize = 2; -const IN_199: usize = 2; -const OUT_199: usize = 1; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_208: usize = 1; +const IN_208: usize = 1; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_7]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, 0u64 => { - let __ret: [G; OUT_199] = [__v_0]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_7 + __v_8); + let __ret: [G; OUT_208] = [__v_9]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __v_2: G = G::from_u64(1); - let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_5: G = __loaded[0]; - let __v_6: G = __loaded[1]; - let __v_7: G = __loaded[2]; - match __v_5.as_canonical_u64() { - 0u64 => { - let __ret: [G; OUT_199] = [__v_7]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); - }, - } + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_200: usize = 1; -const IN_200: usize = 1; -const OUT_200: usize = 1; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_209: usize = 1; +const IN_209: usize = 1; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; @@ -19749,17 +20592,17 @@ fn aiur_fn_200( match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_200] = [__v_8]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_8]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); - let __ret: [G; OUT_200] = [__v_10]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_10]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19769,15 +20612,15 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 1; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_210: usize = 1; +const IN_210: usize = 1; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -19794,17 +20637,17 @@ fn aiur_fn_201( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_201] = [__v_11]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_11]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_201] = [__v_13]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_13]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19814,19 +20657,19 @@ fn aiur_fn_201( }) } -const INPUT_SIZE_202: usize = 2; -const IN_202: usize = 2; -const OUT_202: usize = 4; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_211: usize = 2; +const IN_211: usize = 2; +const OUT_211: usize = 4; +fn aiur_fn_211( + inp: [G; IN_211], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -19837,8 +20680,8 @@ fn aiur_fn_202( let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_202] = [__v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19848,40 +20691,149 @@ fn aiur_fn_202( }) } -const INPUT_SIZE_203: usize = 1; -const IN_203: usize = 1; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_212: usize = 1; +const IN_212: usize = 1; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_212] = [__v_4]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_212] = [__v_4]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_213: usize = 2; +const IN_213: usize = 2; +const OUT_213: usize = 2; +fn aiur_fn_213( + inp: [G; IN_213], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_213], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_213] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_214: usize = 2; +const IN_214: usize = 2; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: [G; IN_214], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_214], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_214] = [__v_1]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_214] = [__v_14]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 1; +const IN_215: usize = 1; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_215], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; - let __v_6: G = __loaded[5]; - let __v_7: G = __loaded[6]; - let __v_8: G = __loaded[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_203] = [__v_9]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_215] = [__v_6]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = G::from_u64(1); - let __v_11: G = (__v_9 + __v_10); - let __ret: [G; OUT_203] = [__v_11]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_6 + __v_7); + let __ret: [G; OUT_215] = [__v_8]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19891,35 +20843,82 @@ fn aiur_fn_203( }) } -const INPUT_SIZE_204: usize = 1; -const IN_204: usize = 1; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_216: usize = 2; +const IN_216: usize = 2; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_216] = [__v_0]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_216] = [__v_7]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_217: usize = 1; +const IN_217: usize = 1; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_204] = [__v_4]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_217] = [__v_9]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __v_5: G = G::from_u64(1); - let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_204] = [__v_6]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_9 + __v_10); + let __ret: [G; OUT_217] = [__v_11]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19929,28 +20928,28 @@ fn aiur_fn_204( }) } -const INPUT_SIZE_205: usize = 2; -const IN_205: usize = 2; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_205] = [__v_0]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_0]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -19959,8 +20958,8 @@ fn aiur_fn_205( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_205] = [__v_8]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_8]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19972,28 +20971,28 @@ fn aiur_fn_205( }) } -const INPUT_SIZE_206: usize = 2; -const IN_206: usize = 2; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_219: usize = 2; +const IN_219: usize = 2; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_206] = [__v_0]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_0]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -20004,8 +21003,8 @@ fn aiur_fn_206( let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_206] = [__v_10]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_10]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21059,6 +22058,71 @@ pub(crate) fn execute_generated( let __out = aiur_fn_206(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 207u64 => { + let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_207(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 208u64 => { + let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_208(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 209u64 => { + let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_209(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 210u64 => { + let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_210(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 211u64 => { + let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_211(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 212u64 => { + let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_212(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 213u64 => { + let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_213(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 214u64 => { + let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_214(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 215u64 => { + let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_215(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 216u64 => { + let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_216(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 217u64 => { + let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_217(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 218u64 => { + let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_218(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 219u64 => { + let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_219(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From b851beac17f14d56d9dac660c4fe9925353a966c Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Tue, 1 Sep 2026 13:21:43 -0400 Subject: [PATCH 4/6] Pin benchmark codegen to the CI fleet's common ISA The Warp x64 runner pool mixes Intel Granite Rapids and AMD Zen 5, and a build job may land on one vendor while the job that runs its binaries lands on the other. Neither vendor's feature set contains the other's, so `-Ctarget-cpu=native` does not produce a portable binary: Zen 5 enables SSE4A, and LLVM emits it. Disassembling the workspace built for znver5 finds 31 SSE4A instructions, all INSERTQ, in `ix-ffi` and in `aiur_ixvm_witness::add_entries_parallel`. Granite Rapids has no SSE4A, so the first one executed raises #UD, killing the process with SIGILL during witness generation. That is what turned every row of #605's benchmark into a crash. Pin the measured intersection of the two CPUs instead. x86-64-v4 covers every AVX-512 subset Plonky3 uses; +avx512vbmi2 preserves its VPSHRDQ interleave and +gfni preserves LLVM's byte-shift lowering. A workspace built with these flags contains no instruction absent from either vendor and has an instruction vocabulary identical to a graniterapids build. blake3 dispatches on CPUID at runtime and is unaffected either way. `.cargo/config.toml` keeps `-Ctarget-cpu=native`: a developer builds and runs on one machine, and x86-64-v4 would exclude every host without AVX-512. Only CI has the split, so only CI pins the ISA. The new guard fails the job when a runner lacks a required feature, so the assumption is enforced rather than assumed, and the shared `warp-x64` cargo cache key becomes sound now that codegen no longer varies by host. RUSTFLAGS is hashed into that key, so the flag change rotates it on its own. Pinning also removes a benchmarking hazard that never crashed: LLVM sets prefer-256-bit for Granite Rapids but not for Zen 5, so the same source vectorized 3.2x more widely depending on the build host, and main-vs-PR timings were not comparable across a vendor split. --- .../actions/setup-rust-toolchain/action.yml | 33 ++++++++++++++++--- .github/workflows/merge-tests.yml | 4 +-- 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/.github/actions/setup-rust-toolchain/action.yml b/.github/actions/setup-rust-toolchain/action.yml index db4211710..6a30f58e8 100644 --- a/.github/actions/setup-rust-toolchain/action.yml +++ b/.github/actions/setup-rust-toolchain/action.yml @@ -7,8 +7,8 @@ inputs: cache-workspaces: description: Cargo workspaces to cache required: false - native-codegen: - description: Enable code generation for the runner's native CPU + avx512-codegen: + description: Enable AVX-512 code generation for the Warp x64 fleet's common ISA required: false default: "true" @@ -27,10 +27,33 @@ runs: exit 1 fi + # The fleet mixes Intel Granite Rapids and AMD Zen 5, and a binary may be + # built on one and measured on another. Neither vendor's feature set + # contains the other's, so `-Ctarget-cpu=native` is not portable across + # the fleet: Zen 5 enables SSE4A, which LLVM emits (as INSERTQ, in + # witness generation) and Intel traps on with #UD. Pin the measured + # intersection instead. x86-64-v4 covers every AVX-512 subset Plonky3 + # uses; +avx512vbmi2 keeps its VPSHRDQ interleave and +gfni keeps LLVM's + # byte-shift lowering. blake3 selects its kernels via CPUID at runtime + # and is unaffected. Pinning also makes codegen host-independent, so the + # cache key below is sound and main-vs-PR timings stay comparable. + - name: Require the fleet's baseline CPU features + if: inputs.avx512-codegen == 'true' + shell: bash + run: | + missing=() + for f in avx512f avx512bw avx512cd avx512dq avx512vl avx512_vbmi2 gfni; do + grep -qw "$f" /proc/cpuinfo || missing+=("$f") + done + if [ ${#missing[@]} -gt 0 ]; then + echo "::error::Runner CPU lacks required feature(s): ${missing[*]}. Benchmark binaries are built for x86-64-v4 +avx512vbmi2,+gfni." + exit 1 + fi + - uses: actions-rust-lang/setup-rust-toolchain@v1 with: - rustflags: ${{ inputs.native-codegen == 'true' && '-Ctarget-cpu=native -Dwarnings' || '-Dwarnings' }} - # `target/` may contain host-executed native code. Every caller runs - # within the Warp x64 compatibility domain. + rustflags: ${{ inputs.avx512-codegen == 'true' && '-Ctarget-cpu=x86-64-v4 -Ctarget-feature=+avx512vbmi2,+gfni -Dwarnings' || '-Dwarnings' }} + # Codegen is pinned above, so `target/` artifacts are interchangeable + # across every Warp x64 host. cache-key: warp-x64 cache-workspaces: ${{ inputs.cache-workspaces }} diff --git a/.github/workflows/merge-tests.yml b/.github/workflows/merge-tests.yml index 161dacae2..dccdf83cd 100644 --- a/.github/workflows/merge-tests.yml +++ b/.github/workflows/merge-tests.yml @@ -68,8 +68,8 @@ jobs: - uses: actions/checkout@v7 - uses: ./.github/actions/setup-rust-toolchain with: - # Valgrind cannot decode AVX-512 emitted by native codegen. - native-codegen: ${{ matrix.kind != 'valgrind' }} + # Valgrind cannot decode the AVX-512 the fleet baseline emits. + avx512-codegen: ${{ matrix.kind != 'valgrind' }} # A merge group has its own SHA, so restore the nearest compatible build # produced by ordinary CI and let Lake rebuild anything that changed. From e7f3dd5ed6ccecc3bac87d7acf31a324da799f9e Mon Sep 17 00:00:00 2001 From: Samuel Burnham <45365069+samuelburnham@users.noreply.github.com> Date: Tue, 1 Sep 2026 20:31:21 -0400 Subject: [PATCH 5/6] fix: Authenticate all frontier group members in the recursive verifier (#606) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Authenticate all frontier group members in the recursive verifier The in-circuit pruned-multiproof walk (mmcs_verify_multi / frontier_level) collapses queries that share a parent to a single lead node and hashes only the lead's rows via inject_maybe(ar, ...). Non-lead members' opened rows for the shorter (injected) matrices were still consumed in their own per-query FRI arithmetic (batch_views_at) but never authenticated against any commitment — the leaf hash covers only the tallest matrices, and shorter ones are bound solely through injection. A prover could therefore forge a non-lead member's shorter-matrix opening. Plonky3's reference verify_batch_pruned guards exactly this with InconsistentGroupOpening (and InconsistentDuplicateOpenings for equal-index queries); the port had neither. The prior per-query walk did not have the gap, so it was introduced with the direct multiproof consumption. - frontier_level: on a group merge, assert the lead and member agree on every not-yet-injected matrix (height <= next_lh) via select_rows_le + pointer equality. Transitive across pairwise merges, so the whole group is pinned; matches InconsistentGroupOpening. - frontier_merge: duplicate transcript indices must open the SAME full rows, not merely the same tallest-matrix leaf digest; matches InconsistentDuplicateOpenings. Pointer equality is admissible inside assert_eq! (equal pointers imply equal content; a spurious mismatch costs only completeness — see IxVM.Core). select_rows_le selects rows of matrices at height <= target, mirroring select_rows. Validated: the group-merge branch is genuinely reached by the factorial recursion proof (an always-false variant of the new assert fails the honest test), the honest proof still verifies with the real assert (completeness preserved), the existing tamper tests still reject, and the full lake test suite is green (2717 checks). aiur_multi_stark.rs regenerated; kernel executor unchanged. * Drop the multi_stark::advice dependency Companion to multi-stark removing its unused per-query advice module. ix consumed native pruned multiproofs directly and referenced only advice::AdviceError, whose two arms (verification failed, serialization failed) were immediately string-formatted by the FFI. Replace it with a plain Result, String>: AiurSystem::proof_to_advice_bytes maps both failures to a message, and the FFI passes the string straight to LeanExcept::error_string. No behavior change; the Lean binding (Except String ByteArray) is unaffected. Bump the multi-stark pin to the advice-removed revision. Requires that multi-stark's ap/bump-p3-drop-advice be pushed first, exactly as with every other pin in this series. * Bump multi-stark audit revision --------- Co-authored-by: Arthur Paulino --- Cargo.lock | 2 +- Cargo.toml | 2 +- Ix/MultiStark/Pcs.lean | 48 +- crates/aiur/src/synthesis.rs | 8 +- crates/ffi/src/aiur/protocol.rs | 2 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 3576 ++++++++++--------- 6 files changed, 1887 insertions(+), 1751 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0141466ef..ef7bf2676 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2104,7 +2104,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=33b4454aa63b88427b3d3cc09980fe86ddeb7e5f#33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=8f3c50d8f48aad2efc90c24729c441677b296fe2#8f3c50d8f48aad2efc90c24729c441677b296fe2" dependencies = [ "bincode", "itertools 0.14.0", diff --git a/Cargo.toml b/Cargo.toml index 70d17d38e..3c5b0be03 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,7 +56,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "8f3c50d8f48aad2efc90c24729c441677b296fe2" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean index 9ac8b4c65..0947e1d27 100644 --- a/Ix/MultiStark/Pcs.lean +++ b/Ix/MultiStark/Pcs.lean @@ -389,6 +389,27 @@ def pcs := ⟦ } } + -- Rows of matrices at log-height <= `target`, in circuit order. Used to + -- cross-check that two frontier queries sharing a parent agree on every + -- not-yet-injected (shorter) matrix: only the group lead's rows are hashed + -- into the shared frontier, so the others must be pinned to match it + -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`). Skips + -- empty (inactive-circuit) rows exactly as `select_rows`. + fn select_rows_le(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› { + match load(rows) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(r, rrest) => + let &ListNode.Cons(lh, lrest) = lhs; + match u32_less_than(target, lh) { + 1 => select_rows_le(rrest, lrest, target), + _ => match load(r) { + ListNode.Nil => select_rows_le(rrest, lrest, target), + _ => store(ListNode.Cons(r, select_rows_le(rrest, lrest, target))), + }, + }, + } + } + -- Pop one canonicalized lane across row boundaries. `got = 0` iff both the -- current row and the remaining rows are exhausted (selected rows are -- non-empty, so advancing to the next row always yields a lane). @@ -525,16 +546,20 @@ def pcs := ⟦ ListNode.Cons(x, xrest) => match load(ys) { ListNode.Nil => xs, ListNode.Cons(y, yrest) => - let FrontierNode.Mk(xi, _xb, _xr, xd) = x; - let FrontierNode.Mk(yi, _yb, _yr, yd) = y; + let FrontierNode.Mk(xi, _xb, xr, xd) = x; + let FrontierNode.Mk(yi, _yb, yr, yd) = y; match memo_u32_less_than(xi, yi) { 1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))), _ => match eq_zero(xi - yi) { 1 => - -- Duplicate transcript queries must open the same leaf. A - -- direct pointer assertion is sound here: only equality is - -- accepted; non-canonical equal digests can at worst reject. + -- Duplicate transcript queries (same index) must open the + -- SAME full opened rows, not merely the same tallest-matrix + -- leaf digest: their shorter-matrix rows share a reduced index + -- too and both feed the FRI arithmetic (Plonky3 + -- `verify_batch_pruned`'s `InconsistentDuplicateOpenings`). + -- Pointer equality is admissible inside `assert_eq!`. assert_eq!(ptr_val(xd), ptr_val(yd)); + assert_eq!(ptr_val(xr), ptr_val(yr)); store(ListNode.Cons(x, frontier_merge(xrest, yrest))), _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))), }, @@ -595,10 +620,21 @@ def pcs := ⟦ let aparent = bits_to_num(aparent_bits); match load(rest) { ListNode.Cons(b, brest) => - let FrontierNode.Mk(bi, bbits, _br, bd) = b; + let FrontierNode.Mk(bi, bbits, br, bd) = b; let &ListNode.Cons(_bbit, bparent_bits) = bbits; match eq_zero(aparent - bits_to_num(bparent_bits)) { 1 => + -- Group members sharing a parent are collapsed to the lead + -- `a`; only `ar` is injected from here up, so `b` must agree + -- with `a` on every not-yet-injected (height <= next_lh) + -- matrix. Otherwise `b`'s shorter-matrix opened rows, still + -- consumed in its own FRI arithmetic, would go unauthenticated + -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`; + -- pointer equality is admissible inside `assert_eq!` — see + -- `IxVM.Core`). Transitive across pairwise merges, so the whole + -- group is pinned. + assert_eq!(ptr_val(select_rows_le(ar, lhs, next_lh)), + ptr_val(select_rows_le(br, lhs, next_lh))); let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd)); let (tail, p2) = frontier_level(brest, proof, lhs, next_lh); (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 1bfec2b9d..3e833a752 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -450,11 +450,9 @@ impl AiurSystem { &self, claim: &[G], proof: &AiurProof, - ) -> Result, multi_stark::advice::AdviceError> { - self.verify(claim, proof).map_err(|e| { - multi_stark::advice::AdviceError::Verification(format!("{e:?}")) - })?; - proof.to_bytes().map_err(multi_stark::advice::AdviceError::Encode) + ) -> Result, String> { + self.verify(claim, proof).map_err(|e| format!("{e:?}"))?; + proof.to_bytes().map_err(|e| format!("{e:?}")) } } diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 167c8ace1..4247d342a 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -154,7 +154,7 @@ extern "C" fn rs_aiur_proof_to_advice_bytes( let claim = claim.map(|x| lean_unbox_g(&x)); match aiur_system_obj.get().proof_to_advice_bytes(&claim, proof_obj.get()) { Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), - Err(err) => LeanExcept::error_string(&format!("{err:?}")), + Err(err) => LeanExcept::error_string(&err), } } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 9887d66c4..15e6ebc8a 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -4667,7 +4667,7 @@ fn aiur_fn_69( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -4848,10 +4848,10 @@ fn aiur_fn_69( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -9158,7 +9158,7 @@ fn aiur_fn_94( let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; let __ret: [G; OUT_94] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105]; if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -9660,15 +9660,102 @@ fn aiur_fn_101( }) } -const INPUT_SIZE_102: usize = 2; -const IN_102: usize = 2; -const OUT_102: usize = 11; +const INPUT_SIZE_102: usize = 3; +const IN_102: usize = 3; +const OUT_102: usize = 1; fn aiur_fn_102( inp: [G; IN_102], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_102] = [__v_8]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_102] = [__v_10]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_102] = [__v_20]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_102] = [__v_22]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_103: usize = 2; +const IN_103: usize = 2; +const OUT_103: usize = 11; +fn aiur_fn_103( + inp: [G; IN_103], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9763,8 +9850,8 @@ fn aiur_fn_102( return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None }); } let __v_78: G = G::from_u64(1); - let __ret: [G; OUT_102] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -9783,12 +9870,12 @@ fn aiur_fn_102( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -9800,8 +9887,8 @@ fn aiur_fn_102( let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; - let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9816,15 +9903,15 @@ fn aiur_fn_102( }) } -const INPUT_SIZE_103: usize = 6; -const IN_103: usize = 6; -const OUT_103: usize = 1; -fn aiur_fn_103( - inp: [G; IN_103], +const INPUT_SIZE_104: usize = 6; +const IN_104: usize = 6; +const OUT_104: usize = 1; +fn aiur_fn_104( + inp: [G; IN_104], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_103], ExecError> { +) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9832,7 +9919,7 @@ fn aiur_fn_103( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -10037,68 +10124,68 @@ fn aiur_fn_103( let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_103] = [__v_187]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_187]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_5]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -10110,7 +10197,7 @@ fn aiur_fn_103( let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -10122,7 +10209,7 @@ fn aiur_fn_103( let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -10134,7 +10221,7 @@ fn aiur_fn_103( let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -10146,7 +10233,7 @@ fn aiur_fn_103( let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -10158,7 +10245,7 @@ fn aiur_fn_103( let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; @@ -10170,7 +10257,7 @@ fn aiur_fn_103( let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; @@ -10353,8 +10440,8 @@ fn aiur_fn_103( 1u64 => { let __v_232: G = G::from_u64(0); let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_103] = [__v_233]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_233]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10415,20 +10502,20 @@ fn aiur_fn_103( let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_283: G = G::from_u64(0); let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_285: G = __r_arr[0]; - let __ret: [G; OUT_103] = [__v_285]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_285]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_232: G = G::from_u64(1); let __v_233: G = (__v_2 + __v_232); let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; - let __ret: [G; OUT_103] = [__v_235]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_235]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -10439,15 +10526,15 @@ fn aiur_fn_103( }) } -const INPUT_SIZE_104: usize = 1; -const IN_104: usize = 1; -const OUT_104: usize = 32; -fn aiur_fn_104( - inp: [G; IN_104], +const INPUT_SIZE_105: usize = 1; +const IN_105: usize = 1; +const OUT_105: usize = 32; +fn aiur_fn_105( + inp: [G; IN_105], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_104], ExecError> { +) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -10499,7 +10586,7 @@ fn aiur_fn_104( let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; @@ -10534,21 +10621,21 @@ fn aiur_fn_104( let __v_80: G = __r_arr[29]; let __v_81: G = __r_arr[30]; let __v_82: G = __r_arr[31]; - let __ret: [G; OUT_104] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; - if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_105] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; + if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_105: usize = 3; -const IN_105: usize = 3; -const OUT_105: usize = 1; -fn aiur_fn_105( - inp: [G; IN_105], +const INPUT_SIZE_106: usize = 3; +const IN_106: usize = 3; +const OUT_106: usize = 1; +fn aiur_fn_106( + inp: [G; IN_106], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_105], ExecError> { +) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10604,7 +10691,7 @@ fn aiur_fn_105( let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; @@ -10640,21 +10727,21 @@ fn aiur_fn_105( let __v_84: G = __r_arr[30]; let __v_85: G = __r_arr[31]; let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_105] = [__v_86]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_106] = [__v_86]; + if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_106: usize = 4; -const IN_106: usize = 4; -const OUT_106: usize = 1; -fn aiur_fn_106( - inp: [G; IN_106], +const INPUT_SIZE_107: usize = 4; +const IN_107: usize = 4; +const OUT_107: usize = 1; +fn aiur_fn_107( + inp: [G; IN_107], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_106], ExecError> { +) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10664,32 +10751,32 @@ fn aiur_fn_106( let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_106] = [__v_3]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_3]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_106] = [__v_6]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_6]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 1; -fn aiur_fn_107( - inp: [G; IN_107], +const INPUT_SIZE_108: usize = 1; +const IN_108: usize = 1; +const OUT_108: usize = 1; +fn aiur_fn_108( + inp: [G; IN_108], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_107], ExecError> { +) -> Result<[G; OUT_108], 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 }; @@ -10699,18 +10786,18 @@ fn aiur_fn_107( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_107] = [__v_4]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_4]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_107] = [__v_7]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_7]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10720,15 +10807,15 @@ fn aiur_fn_107( }) } -const INPUT_SIZE_108: usize = 2; -const IN_108: usize = 2; -const OUT_108: usize = 1; -fn aiur_fn_108( - inp: [G; IN_108], +const INPUT_SIZE_109: usize = 2; +const IN_109: usize = 2; +const OUT_109: usize = 1; +fn aiur_fn_109( + inp: [G; IN_109], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_108], ExecError> { +) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10741,8 +10828,8 @@ fn aiur_fn_108( let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_108] = [__v_1]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_1]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -10755,8 +10842,8 @@ fn aiur_fn_108( let __v_13: G = __loaded[5]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_108] = [__v_0]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_0]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -10769,11 +10856,11 @@ fn aiur_fn_108( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_108] = [__v_17]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_17]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10784,21 +10871,24 @@ fn aiur_fn_108( if (__v_6 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } + if (__v_5 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); + } let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_108] = [__v_19]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_19]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_108] = [__v_19]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_19]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -10821,15 +10911,15 @@ fn aiur_fn_108( }) } -const INPUT_SIZE_109: usize = 1; -const IN_109: usize = 1; -const OUT_109: usize = 2; -fn aiur_fn_109( - inp: [G; IN_109], +const INPUT_SIZE_110: usize = 1; +const IN_110: usize = 1; +const OUT_110: usize = 2; +fn aiur_fn_110( + inp: [G; IN_110], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_109], ExecError> { +) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -10847,8 +10937,8 @@ fn aiur_fn_109( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_109] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -10869,20 +10959,20 @@ fn aiur_fn_109( let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_109] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_109] = [__v_16, __v_18]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_16, __v_18]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10897,15 +10987,15 @@ fn aiur_fn_109( }) } -const INPUT_SIZE_110: usize = 1; -const IN_110: usize = 1; -const OUT_110: usize = 1; -fn aiur_fn_110( - inp: [G; IN_110], +const INPUT_SIZE_111: usize = 1; +const IN_111: usize = 1; +const OUT_111: usize = 1; +fn aiur_fn_111( + inp: [G; IN_111], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_110], ExecError> { +) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -10917,8 +11007,8 @@ fn aiur_fn_110( let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_110] = [__v_0]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_0]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -10931,22 +11021,22 @@ fn aiur_fn_110( let __v_12: G = __loaded[5]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_110] = [__v_0]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_0]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_110] = [__v_17]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_17]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10961,15 +11051,15 @@ fn aiur_fn_110( }) } -const INPUT_SIZE_111: usize = 4; -const IN_111: usize = 4; -const OUT_111: usize = 1; -fn aiur_fn_111( - inp: [G; IN_111], +const INPUT_SIZE_112: usize = 4; +const IN_112: usize = 4; +const OUT_112: usize = 1; +fn aiur_fn_112( + inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_111], ExecError> { +) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10981,7 +11071,7 @@ fn aiur_fn_111( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { @@ -10990,8 +11080,8 @@ fn aiur_fn_111( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_111] = [__v_11]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_11]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11001,16 +11091,16 @@ fn aiur_fn_111( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_111] = [__v_14]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_14]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11025,15 +11115,15 @@ fn aiur_fn_111( }) } -const INPUT_SIZE_112: usize = 4; -const IN_112: usize = 4; -const OUT_112: usize = 2; -fn aiur_fn_112( - inp: [G; IN_112], +const INPUT_SIZE_113: usize = 4; +const IN_113: usize = 4; +const OUT_113: usize = 2; +fn aiur_fn_113( + inp: [G; IN_113], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_112], ExecError> { +) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11051,8 +11141,8 @@ fn aiur_fn_112( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_12, __v_1]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_12, __v_1]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11064,7 +11154,7 @@ fn aiur_fn_112( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -11083,7 +11173,7 @@ fn aiur_fn_112( let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_13 - __v_23); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); @@ -11091,15 +11181,22 @@ fn aiur_fn_112( 1u64 => { let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 6] = [__v_30, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_31, __v_29]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); + } + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_113] = [__v_33, __v_29]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11111,15 +11208,15 @@ fn aiur_fn_112( 0u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_34, __v_32]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_34, __v_32]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11145,15 +11242,15 @@ fn aiur_fn_112( 0u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_29, __v_22]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_29, __v_22]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11180,15 +11277,15 @@ fn aiur_fn_112( }) } -const INPUT_SIZE_113: usize = 4; -const IN_113: usize = 4; -const OUT_113: usize = 2; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_114: usize = 4; +const IN_114: usize = 4; +const OUT_114: usize = 2; +fn aiur_fn_114( + inp: [G; IN_114], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11196,38 +11293,38 @@ fn aiur_fn_113( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_113] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 - __v_8); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_113] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_114: usize = 6; -const IN_114: usize = 6; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_115: usize = 6; +const IN_115: usize = 6; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11235,11 +11332,11 @@ fn aiur_fn_114( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -11253,9 +11350,9 @@ fn aiur_fn_114( 0u64 => { match __v_11.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_bool((__v_18 == G::ZERO)); @@ -11263,24 +11360,24 @@ fn aiur_fn_114( if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_14); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); - let __ret: [G; OUT_114] = [__v_27]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_115] = [__v_27]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11292,15 +11389,15 @@ fn aiur_fn_114( }) } -const INPUT_SIZE_115: usize = 2; -const IN_115: usize = 2; -const OUT_115: usize = 1; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_116: usize = 2; +const IN_116: usize = 2; +const OUT_116: usize = 1; +fn aiur_fn_116( + inp: [G; IN_116], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11310,17 +11407,17 @@ fn aiur_fn_115( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_115] = [__v_1]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_1]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_115] = [__v_7]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_7]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11330,15 +11427,15 @@ fn aiur_fn_115( }) } -const INPUT_SIZE_116: usize = 2; -const IN_116: usize = 2; -const OUT_116: usize = 1; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_117: usize = 2; +const IN_117: usize = 2; +const OUT_117: usize = 1; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11349,24 +11446,24 @@ fn aiur_fn_116( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_116] = [__v_5]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_5]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_116] = [__v_6]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_6]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); - let __ret: [G; OUT_116] = [__v_7]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_7]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11378,15 +11475,15 @@ fn aiur_fn_116( }) } -const INPUT_SIZE_117: usize = 8; -const IN_117: usize = 8; -const OUT_117: usize = 2; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_118: usize = 8; +const IN_118: usize = 8; +const OUT_118: usize = 2; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11398,14 +11495,14 @@ fn aiur_fn_117( let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_15 + __v_15); let __v_17: G = (__v_4 + __v_6); @@ -11487,50 +11584,50 @@ fn aiur_fn_117( let __v_81: G = (__v_79 + __v_80); let __v_82: G = (__v_42 + __v_78); let __v_83: G = (__v_45 + __v_81); - let __ret: [G; OUT_117] = [__v_82, __v_83]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_82, __v_83]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_118: usize = 2; -const IN_118: usize = 2; -const OUT_118: usize = 1; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_119: usize = 2; +const IN_119: usize = 2; +const OUT_119: usize = 1; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_2 * __v_8); - let __ret: [G; OUT_118] = [__v_9]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_9]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_119: usize = 8; -const IN_119: usize = 8; -const OUT_119: usize = 4; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_120: usize = 8; +const IN_120: usize = 8; +const OUT_120: usize = 4; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11553,8 +11650,8 @@ fn aiur_fn_119( let __v_17: G = __loaded[9]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_119] = [__v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11607,13 +11704,13 @@ fn aiur_fn_119( let __v_61: G = (__v_6 * __v_3); let __v_62: G = (__v_7 * __v_2); let __v_63: G = (__v_61 + __v_62); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; - let __ret: [G; OUT_119] = [__v_64, __v_65, __v_66, __v_67]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_64, __v_65, __v_66, __v_67]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11628,15 +11725,15 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 2; -const IN_120: usize = 2; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_121: usize = 2; +const IN_121: usize = 2; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11647,8 +11744,8 @@ fn aiur_fn_120( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_120] = [__v_1]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_1]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11764,14 +11861,14 @@ fn aiur_fn_120( if (__v_94 != __v_95) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; - let __ret: [G; OUT_120] = [__v_98]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_98]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11781,15 +11878,15 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 2; -const IN_121: usize = 2; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_122: usize = 2; +const IN_122: usize = 2; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11799,17 +11896,17 @@ fn aiur_fn_121( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_121] = [__v_1]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_1]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_121] = [__v_6]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_6]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11819,15 +11916,15 @@ fn aiur_fn_121( }) } -const INPUT_SIZE_122: usize = 2; -const IN_122: usize = 2; -const OUT_122: usize = 1; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_123: usize = 2; +const IN_123: usize = 2; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11837,17 +11934,17 @@ fn aiur_fn_122( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_122] = [__v_1]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_1]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_122] = [__v_6]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_6]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11857,30 +11954,30 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 3; -const IN_123: usize = 3; -const OUT_123: usize = 1; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_124: usize = 3; +const IN_124: usize = 3; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_123] = [__v_2]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_2]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_123] = [__v_3]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_3]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11890,15 +11987,15 @@ fn aiur_fn_123( }) } -const INPUT_SIZE_124: usize = 2; -const IN_124: usize = 2; -const OUT_124: usize = 1; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_125: usize = 2; +const IN_125: usize = 2; +const OUT_125: usize = 1; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11908,8 +12005,8 @@ fn aiur_fn_124( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_124] = [__v_0]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_0]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11921,12 +12018,12 @@ fn aiur_fn_124( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_124] = [__v_14]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_14]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11936,15 +12033,15 @@ fn aiur_fn_124( }) } -const INPUT_SIZE_125: usize = 10; -const IN_125: usize = 10; -const OUT_125: usize = 2; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_126: usize = 10; +const IN_126: usize = 10; +const OUT_126: usize = 2; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11961,43 +12058,43 @@ fn aiur_fn_125( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_0, __v_12]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_0, __v_12]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_125] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_126: usize = 4; -const IN_126: usize = 4; -const OUT_126: usize = 2; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_127: usize = 4; +const IN_127: usize = 4; +const OUT_127: usize = 2; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12012,8 +12109,8 @@ fn aiur_fn_126( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_126] = [__v_9, __v_0]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_9, __v_0]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -12030,12 +12127,12 @@ fn aiur_fn_126( let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12054,7 +12151,7 @@ fn aiur_fn_126( let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(0); @@ -12101,8 +12198,8 @@ fn aiur_fn_126( let __v_81: G = (__v_63 + __v_80); let __v_82: G = (__v_28 + __v_81); let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_126] = [__v_83, __v_39]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_83, __v_39]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12117,15 +12214,15 @@ fn aiur_fn_126( }) } -const INPUT_SIZE_127: usize = 5; -const IN_127: usize = 5; -const OUT_127: usize = 1; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_128: usize = 5; +const IN_128: usize = 5; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12135,12 +12232,12 @@ fn aiur_fn_127( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_127] = [__v_5]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_5]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -12148,8 +12245,8 @@ fn aiur_fn_127( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_127] = [__v_9]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_9]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12157,10 +12254,10 @@ fn aiur_fn_127( let __v_10: G = (__v_2 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_127] = [__v_13]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_13]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12169,15 +12266,15 @@ fn aiur_fn_127( }) } -const INPUT_SIZE_128: usize = 4; -const IN_128: usize = 4; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_129: usize = 4; +const IN_129: usize = 4; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12188,22 +12285,22 @@ fn aiur_fn_128( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_128] = [__v_6]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_6]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_8]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_8]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12214,11 +12311,11 @@ fn aiur_fn_128( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_128] = [__v_14]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_14]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12227,15 +12324,15 @@ fn aiur_fn_128( }) } -const INPUT_SIZE_129: usize = 8; -const IN_129: usize = 8; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_130: usize = 8; +const IN_130: usize = 8; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12258,8 +12355,8 @@ fn aiur_fn_129( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_129] = [__v_17]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_17]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -12271,7 +12368,7 @@ fn aiur_fn_129( 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -12288,17 +12385,17 @@ fn aiur_fn_129( let __v_32: G = (__v_13 + __v_30); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_129] = [__v_34]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_34]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_129] = [__v_19]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_19]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12312,15 +12409,15 @@ fn aiur_fn_129( }) } -const INPUT_SIZE_130: usize = 2; -const IN_130: usize = 2; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12335,8 +12432,8 @@ fn aiur_fn_130( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_130] = [__v_9]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_9]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -12358,15 +12455,15 @@ fn aiur_fn_130( return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_130] = [__v_19]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_19]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_130] = [__v_11]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_11]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12380,29 +12477,29 @@ fn aiur_fn_130( }) } -const INPUT_SIZE_131: usize = 2; -const IN_131: usize = 2; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_132: usize = 2; +const IN_132: usize = 2; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { +) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_131] = [__v_2]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_2]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_131] = [__v_2]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_2]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12412,15 +12509,15 @@ fn aiur_fn_131( }) } -const INPUT_SIZE_132: usize = 10; -const IN_132: usize = 10; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_133: usize = 10; +const IN_133: usize = 10; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], ExecError> { +) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12433,17 +12530,17 @@ fn aiur_fn_132( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = (__v_3 - __v_1); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_12 * __v_18); let __v_20: G = G::from_u64(0); @@ -12472,9 +12569,9 @@ fn aiur_fn_132( let __v_37: G = G::from_u64(0); let __v_38: G = (__v_37 - __v_22); let __v_39: G = (__v_38 * __v_28); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_40 - __v_41); let __v_43: G = G::from_bool((__v_42 == G::ZERO)); @@ -12482,23 +12579,23 @@ fn aiur_fn_132( if (__v_43 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_132] = [__v_45]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_133] = [__v_45]; + if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_133: usize = 11; -const IN_133: usize = 11; -const OUT_133: usize = 1; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_134: usize = 11; +const IN_134: usize = 11; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12512,12 +12609,12 @@ fn aiur_fn_133( let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = (__v_5 * __v_15); @@ -12528,25 +12625,25 @@ fn aiur_fn_133( let __v_22: G = (__v_5 * __v_16); let __v_23: G = (__v_6 * __v_15); let __v_24: G = (__v_22 + __v_23); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_133] = [__v_26]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_26]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_134: usize = 13; -const IN_134: usize = 13; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_135: usize = 13; +const IN_135: usize = 13; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12563,43 +12660,43 @@ fn aiur_fn_134( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_134] = [__v_0]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_0]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_4 + __v_18); let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 - __v_20); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_134] = [__v_22]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_22]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_135: usize = 13; -const IN_135: usize = 13; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_136: usize = 13; +const IN_136: usize = 13; +const OUT_136: usize = 1; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12616,46 +12713,46 @@ fn aiur_fn_135( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_135] = [__v_0]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_0]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_4 + __v_20); let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 - __v_22); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_135] = [__v_24]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_24]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_136: usize = 15; -const IN_136: usize = 15; -const OUT_136: usize = 1; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_137: usize = 15; +const IN_137: usize = 15; +const OUT_137: usize = 1; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12674,12 +12771,12 @@ fn aiur_fn_136( let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_136] = [__v_0]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_0]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -12688,21 +12785,21 @@ fn aiur_fn_136( let __v_18: G = (__v_4 + __v_17); let __v_19: G = G::from_u64(1); let __v_20: G = (__v_5 - __v_19); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_136] = [__v_21]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_21]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); @@ -12710,10 +12807,10 @@ fn aiur_fn_136( let __v_25: G = (__v_5 - __v_24); let __v_26: G = G::from_u64(1); let __v_27: G = (__v_6 + __v_26); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_136] = [__v_28]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_28]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12725,15 +12822,15 @@ fn aiur_fn_136( }) } -const INPUT_SIZE_137: usize = 15; -const IN_137: usize = 15; -const OUT_137: usize = 1; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_138: usize = 15; +const IN_138: usize = 15; +const OUT_138: usize = 1; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12752,24 +12849,24 @@ fn aiur_fn_137( let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_137] = [__v_0]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_0]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_20 - __v_21); let __v_23: G = G::from_bool((__v_22 == G::ZERO)); @@ -12779,10 +12876,10 @@ fn aiur_fn_137( } let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_137] = [__v_27]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_27]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12794,15 +12891,15 @@ fn aiur_fn_137( }) } -const INPUT_SIZE_138: usize = 4; -const IN_138: usize = 4; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_139: usize = 4; +const IN_139: usize = 4; +const OUT_139: usize = 1; +fn aiur_fn_139( + inp: [G; IN_139], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12813,39 +12910,39 @@ fn aiur_fn_138( 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_138] = [__v_6]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_6]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_5 + __v_1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_12]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_12]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_139: usize = 1; -const IN_139: usize = 1; -const OUT_139: usize = 1; -fn aiur_fn_139( - inp: [G; IN_139], +const INPUT_SIZE_140: usize = 1; +const IN_140: usize = 1; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { +) -> Result<[G; OUT_140], 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 }; @@ -12855,23 +12952,23 @@ fn aiur_fn_139( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_139] = [__v_4]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_4]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_139] = [__v_4]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_4]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_139] = [__v_2]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_2]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -12883,15 +12980,15 @@ fn aiur_fn_139( }) } -const INPUT_SIZE_140: usize = 5; -const IN_140: usize = 5; -const OUT_140: usize = 1; -fn aiur_fn_140( - inp: [G; IN_140], +const INPUT_SIZE_141: usize = 5; +const IN_141: usize = 5; +const OUT_141: usize = 1; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { +) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12903,12 +13000,12 @@ fn aiur_fn_140( 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_140] = [__v_7]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_7]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -12917,26 +13014,26 @@ fn aiur_fn_140( let __v_8: G = (__v_3 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_140] = [__v_11]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_11]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_8 + __v_1); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 - __v_10); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_140] = [__v_15]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_15]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12948,15 +13045,15 @@ fn aiur_fn_140( }) } -const INPUT_SIZE_141: usize = 5; -const IN_141: usize = 5; -const OUT_141: usize = 4; -fn aiur_fn_141( - inp: [G; IN_141], +const INPUT_SIZE_142: usize = 5; +const IN_142: usize = 5; +const OUT_142: usize = 4; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_141], ExecError> { +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12965,28 +13062,28 @@ fn aiur_fn_141( let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_141] = [__v_1, __v_2, __v_3, __v_4]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_1, __v_2, __v_3, __v_4]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_141] = [__v_3, __v_4, __v_1, __v_2]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_3, __v_4, __v_1, __v_2]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_142: usize = 4; -const IN_142: usize = 4; -const OUT_142: usize = 1; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_143: usize = 4; +const IN_143: usize = 4; +const OUT_143: usize = 1; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13227,21 +13324,21 @@ fn aiur_fn_142( let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_142] = [__v_194]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_194]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_143: usize = 6; -const IN_143: usize = 6; -const OUT_143: usize = 3; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_144: usize = 6; +const IN_144: usize = 6; +const OUT_144: usize = 3; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13259,8 +13356,8 @@ fn aiur_fn_143( let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_0, __v_1, __v_5]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13271,7 +13368,7 @@ fn aiur_fn_143( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); @@ -13284,13 +13381,13 @@ fn aiur_fn_143( let __v_25: G = (__v_23 + __v_24); let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); - let __ret: [G; OUT_143] = [__v_26, __v_27, __v_12]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_26, __v_27, __v_12]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_0, __v_1, __v_5]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -13304,15 +13401,15 @@ fn aiur_fn_143( }) } -const INPUT_SIZE_144: usize = 9; -const IN_144: usize = 9; -const OUT_144: usize = 3; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_145: usize = 9; +const IN_145: usize = 9; +const OUT_145: usize = 3; +fn aiur_fn_145( + inp: [G; IN_145], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { +) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13336,7 +13433,7 @@ fn aiur_fn_144( if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { @@ -13345,8 +13442,8 @@ fn aiur_fn_144( let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_144] = [__v_0, __v_1, __v_20]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_0, __v_1, __v_20]; + if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -13374,7 +13471,7 @@ fn aiur_fn_144( let __v_23: G = G::from_u64(1); let __v_24: G = (__v_6 - __v_23); let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() { @@ -13390,14 +13487,14 @@ fn aiur_fn_144( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = __mc_out___mc_0[2]; let __v_31: G = __mc_out___mc_0[3]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -13493,7 +13590,7 @@ fn aiur_fn_144( let __v_109: G = (__v_95 + __v_108); let __v_110: G = (__v_94 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = G::from_u64(1); if (__v_112 != __v_113) { @@ -13644,8 +13741,8 @@ fn aiur_fn_144( let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_144] = [__v_37, __v_38, __v_234]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_37, __v_38, __v_234]; + if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13672,15 +13769,15 @@ fn aiur_fn_144( }) } -const INPUT_SIZE_145: usize = 25; -const IN_145: usize = 25; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_146: usize = 25; +const IN_146: usize = 25; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: [G; IN_146], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13709,38 +13806,38 @@ fn aiur_fn_145( let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_33.as_canonical_u64() { _ => { let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { _ => { let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_40, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_40, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_42: G = __loaded[0]; @@ -13754,15 +13851,15 @@ fn aiur_fn_145( 0u64 => { match __v_43.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_23, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_23, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_55 - __v_24); let __v_57: G = G::from_bool((__v_56 == G::ZERO)); @@ -13770,10 +13867,10 @@ fn aiur_fn_145( if (__v_57 != __v_58) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(3); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 - __v_62); @@ -13782,7 +13879,7 @@ fn aiur_fn_145( if (__v_64 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = (__v_66 - __v_18); let __v_68: G = G::from_bool((__v_67 == G::ZERO)); @@ -13790,7 +13887,7 @@ fn aiur_fn_145( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = (__v_70 - __v_18); let __v_72: G = G::from_bool((__v_71 == G::ZERO)); @@ -13798,7 +13895,7 @@ fn aiur_fn_145( if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = (__v_74 - __v_18); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); @@ -13821,8 +13918,8 @@ fn aiur_fn_145( if (__v_85 != __v_86) { return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_145] = [__v_51]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_146] = [__v_51]; + if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -13842,15 +13939,15 @@ fn aiur_fn_145( }) } -const INPUT_SIZE_146: usize = 25; -const IN_146: usize = 25; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], +const INPUT_SIZE_147: usize = 25; +const IN_147: usize = 25; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: [G; IN_147], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { +) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13887,23 +13984,23 @@ fn aiur_fn_146( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_146] = [__v_31]; - if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_147] = [__v_31]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_146] = [__v_35]; - if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_147] = [__v_35]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13913,15 +14010,15 @@ fn aiur_fn_146( }) } -const INPUT_SIZE_147: usize = 4; -const IN_147: usize = 4; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_148: usize = 4; +const IN_148: usize = 4; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13932,38 +14029,38 @@ fn aiur_fn_147( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_147] = [__v_6]; - if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_148] = [__v_6]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_147] = [__v_11]; - if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_148] = [__v_11]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_148: usize = 2; -const IN_148: usize = 2; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_149: usize = 2; +const IN_149: usize = 2; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13977,21 +14074,21 @@ fn aiur_fn_148( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_148] = [__v_8]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_149] = [__v_8]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_148] = [__v_9]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_149] = [__v_9]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14000,18 +14097,18 @@ fn aiur_fn_148( return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } - }) -} - -const INPUT_SIZE_149: usize = 2; -const IN_149: usize = 2; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], + }) +} + +const INPUT_SIZE_150: usize = 2; +const IN_150: usize = 2; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14026,21 +14123,21 @@ fn aiur_fn_149( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_9]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_150] = [__v_9]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_10]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_150] = [__v_10]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14052,15 +14149,15 @@ fn aiur_fn_149( }) } -const INPUT_SIZE_150: usize = 4; -const IN_150: usize = 4; -const OUT_150: usize = 1; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_151: usize = 4; +const IN_151: usize = 4; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], ExecError> { +) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14071,40 +14168,40 @@ fn aiur_fn_150( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_150] = [__v_6]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_151] = [__v_6]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_150] = [__v_12]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_151] = [__v_12]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_151: usize = 13; -const IN_151: usize = 13; -const OUT_151: usize = 1; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_152: usize = 13; +const IN_152: usize = 13; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], ExecError> { +) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14120,39 +14217,39 @@ fn aiur_fn_151( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { _ => { let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { _ => { let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { @@ -14161,29 +14258,29 @@ fn aiur_fn_151( match __v_6.as_canonical_u64() { 0u64 => { let __v_30: G = G::from_u64(1); - let __ret: [G; OUT_151] = [__v_30]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_152] = [__v_30]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_30: G = G::from_u64(3); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_12 - __v_35); - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __ret: [G; OUT_151] = [__v_38]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_152] = [__v_38]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14201,15 +14298,15 @@ fn aiur_fn_151( }) } -const INPUT_SIZE_152: usize = 2; -const IN_152: usize = 2; -const OUT_152: usize = 1; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_153: usize = 2; +const IN_153: usize = 2; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14219,19 +14316,19 @@ fn aiur_fn_152( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_152] = [__v_0]; - if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_153] = [__v_0]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_152] = [__v_8]; - if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_153] = [__v_8]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14241,15 +14338,15 @@ fn aiur_fn_152( }) } -const INPUT_SIZE_153: usize = 2; -const IN_153: usize = 2; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_154: usize = 2; +const IN_154: usize = 2; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14262,24 +14359,24 @@ fn aiur_fn_153( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_7]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_154] = [__v_7]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_13]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_154] = [__v_13]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14289,15 +14386,15 @@ fn aiur_fn_153( }) } -const INPUT_SIZE_154: usize = 6; -const IN_154: usize = 6; -const OUT_154: usize = 1; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_155: usize = 6; +const IN_155: usize = 6; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: [G; IN_155], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14313,11 +14410,11 @@ fn aiur_fn_154( let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); - let __ret: [G; OUT_154] = [__v_12]; - if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_155] = [__v_12]; + if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14330,7 +14427,7 @@ fn aiur_fn_154( match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 - __v_16); @@ -14338,21 +14435,21 @@ fn aiur_fn_154( if (__v_7 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { @@ -14360,10 +14457,10 @@ fn aiur_fn_154( } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_4 + __v_29); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_154] = [__v_31]; - if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_155] = [__v_31]; + if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14380,15 +14477,15 @@ fn aiur_fn_154( }) } -const INPUT_SIZE_155: usize = 32; -const IN_155: usize = 32; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_156: usize = 32; +const IN_156: usize = 32; +const OUT_156: usize = 1; +fn aiur_fn_156( + inp: [G; IN_156], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14424,7 +14521,7 @@ fn aiur_fn_155( let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -14434,7 +14531,7 @@ fn aiur_fn_155( break '__mc_0 [__v_35]; }, 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; break '__mc_0 [__v_36]; }, @@ -14444,18 +14541,18 @@ fn aiur_fn_155( } }; let __v_36: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = G::from_u64(1); let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -14516,30 +14613,30 @@ fn aiur_fn_155( let __v_101: G = (__v_86 + __v_100); let __v_102: G = (__v_84 + __v_101); let __v_103: G = (__v_52 + __v_102); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(1); let __v_107: G = G::from_u64(1); let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_105, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_105, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_110, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_110, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = (__v_32 + __v_28); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(0); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = (__v_119 - __v_32); let __v_121: G = G::from_bool((__v_120 == G::ZERO)); @@ -14547,16 +14644,16 @@ fn aiur_fn_155( if (__v_121 != __v_122) { return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = G::from_u64(3); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = (__v_124 + __v_125); if (__v_123 != __v_126) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = (__v_127 - __v_32); let __v_129: G = G::from_bool((__v_128 == G::ZERO)); @@ -14564,7 +14661,7 @@ fn aiur_fn_155( if (__v_129 != __v_130) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = G::from_u64(1); if (__v_131 != __v_132) { @@ -14576,53 +14673,53 @@ fn aiur_fn_155( if (__v_134 != __v_135) { return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = G::from_u64(1); if (__v_136 != __v_137) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None }); } let __v_138: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; - let __ret: [G; OUT_155] = [__v_139]; - if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_156] = [__v_139]; + if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_156: usize = 2; -const IN_156: usize = 2; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_157: usize = 2; +const IN_157: usize = 2; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool((__v_0 == G::ZERO)); let __v_3: G = G::from_bool((__v_1 == G::ZERO)); let __v_4: G = (__v_2 * __v_3); - let __ret: [G; OUT_156] = [__v_4]; - if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_157] = [__v_4]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 1; -const IN_157: usize = 1; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_158: usize = 1; +const IN_158: usize = 1; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -14633,8 +14730,8 @@ fn aiur_fn_157( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_157] = [__v_5]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_5]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14648,15 +14745,15 @@ fn aiur_fn_157( let __v_9: G = G::from_bool((__v_2 == G::ZERO)); let __v_10: G = G::from_bool((__v_3 == G::ZERO)); let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_157] = [__v_11]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_11]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_157] = [__v_9]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_9]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14668,15 +14765,15 @@ fn aiur_fn_157( }) } -const INPUT_SIZE_158: usize = 9; -const IN_158: usize = 9; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_159: usize = 9; +const IN_159: usize = 9; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14703,21 +14800,21 @@ fn aiur_fn_158( let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_158] = [__v_24]; - if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_159] = [__v_24]; + if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_159: usize = 33; -const IN_159: usize = 33; -const OUT_159: usize = 1; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_160: usize = 33; +const IN_160: usize = 33; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: [G; IN_160], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14752,29 +14849,29 @@ fn aiur_fn_159( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_159] = [__v_36]; - if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_160] = [__v_36]; + if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 2; -const IN_160: usize = 2; -const OUT_160: usize = 1; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_161: usize = 2; +const IN_161: usize = 2; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14784,8 +14881,8 @@ fn aiur_fn_160( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_160] = [__v_1]; - if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_1]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14822,18 +14919,18 @@ fn aiur_fn_160( let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __ret: [G; OUT_160] = [__v_41]; - if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_41]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14843,15 +14940,15 @@ fn aiur_fn_160( }) } -const INPUT_SIZE_161: usize = 2; -const IN_161: usize = 2; -const OUT_161: usize = 1; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_162: usize = 2; +const IN_162: usize = 2; +const OUT_162: usize = 1; +fn aiur_fn_162( + inp: [G; IN_162], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_161], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14861,8 +14958,8 @@ fn aiur_fn_161( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_161] = [__v_1]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_1]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14873,12 +14970,12 @@ fn aiur_fn_161( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_161] = [__v_13]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_13]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14888,15 +14985,15 @@ fn aiur_fn_161( }) } -const INPUT_SIZE_162: usize = 2; -const IN_162: usize = 2; -const OUT_162: usize = 10; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_163: usize = 2; +const IN_163: usize = 2; +const OUT_163: usize = 10; +fn aiur_fn_163( + inp: [G; IN_163], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15013,7 +15110,7 @@ fn aiur_fn_162( let __v_99: G = G::from_u64(1); let __v_100: G = G::from_u64(1); let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; @@ -15063,8 +15160,8 @@ fn aiur_fn_162( let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_162] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15150,8 +15247,8 @@ fn aiur_fn_162( let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_162] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15196,19 +15293,19 @@ fn aiur_fn_162( }) } -const INPUT_SIZE_163: usize = 2; -const IN_163: usize = 2; -const OUT_163: usize = 10; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_164: usize = 2; +const IN_164: usize = 2; +const OUT_164: usize = 10; +fn aiur_fn_164( + inp: [G; IN_164], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -15236,12 +15333,12 @@ fn aiur_fn_163( let __v_26: G = (__v_22 - __v_25); match __v_26.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_163] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_164] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -15252,27 +15349,27 @@ fn aiur_fn_163( let __v_34: G = __r_arr[7]; let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; - let __ret: [G; OUT_163] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_164] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_164: usize = 2; -const IN_164: usize = 2; -const OUT_164: usize = 18; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_165: usize = 2; +const IN_165: usize = 2; +const OUT_165: usize = 18; +fn aiur_fn_165( + inp: [G; IN_165], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -15283,7 +15380,7 @@ fn aiur_fn_164( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -15294,21 +15391,21 @@ fn aiur_fn_164( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __ret: [G; OUT_164] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_165] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_165: usize = 2; -const IN_165: usize = 2; -const OUT_165: usize = 1; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_166: usize = 2; +const IN_166: usize = 2; +const OUT_166: usize = 1; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15317,8 +15414,8 @@ fn aiur_fn_165( 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_165] = [__v_4]; - if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_166] = [__v_4]; + if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15331,11 +15428,11 @@ fn aiur_fn_165( 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_165] = { let __args: [G; IN_165] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_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_165] = [__v_9]; - if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_166] = [__v_9]; + if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15347,20 +15444,20 @@ fn aiur_fn_165( }) } -const INPUT_SIZE_166: usize = 3; -const IN_166: usize = 3; -const OUT_166: usize = 3; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_167: usize = 3; +const IN_167: usize = 3; +const OUT_167: usize = 3; +fn aiur_fn_167( + inp: [G; IN_167], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -15410,31 +15507,31 @@ fn aiur_fn_166( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_166] = [__v_52, __v_11, __v_12]; - if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_167] = [__v_52, __v_11, __v_12]; + if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_167: usize = 9; -const IN_167: usize = 9; -const OUT_167: usize = 1; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_168: usize = 9; +const IN_168: usize = 9; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15448,50 +15545,50 @@ fn aiur_fn_167( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_167] = [__v_13]; - if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_168] = [__v_13]; + if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 2; -const IN_168: usize = 2; -const OUT_168: usize = 1; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_169: usize = 2; +const IN_169: usize = 2; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_168], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = 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_160] = { let __args: [G; IN_160] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_168] = [__v_6]; - if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_169] = [__v_6]; + if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_169: usize = 1; -const IN_169: usize = 1; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_170: usize = 1; +const IN_170: usize = 1; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -15536,21 +15633,21 @@ fn aiur_fn_169( let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_42]; - if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_170] = [__v_42]; + if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_170: usize = 2; -const IN_170: usize = 2; -const OUT_170: usize = 1; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_171: usize = 2; +const IN_171: usize = 2; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15567,17 +15664,17 @@ fn aiur_fn_170( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_170] = [__v_1]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_1]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_170] = [__v_13]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_13]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15587,15 +15684,15 @@ fn aiur_fn_170( }) } -const INPUT_SIZE_171: usize = 2; -const IN_171: usize = 2; -const OUT_171: usize = 1; -fn aiur_fn_171( - inp: [G; IN_171], +const INPUT_SIZE_172: usize = 2; +const IN_172: usize = 2; +const OUT_172: usize = 1; +fn aiur_fn_172( + inp: [G; IN_172], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15604,13 +15701,13 @@ fn aiur_fn_171( 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_171] = [__v_4]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_172] = [__v_4]; + if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_171] = [__v_1]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_172] = [__v_1]; + if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15620,15 +15717,15 @@ fn aiur_fn_171( }) } -const INPUT_SIZE_172: usize = 9; -const IN_172: usize = 9; -const OUT_172: usize = 9; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_173: usize = 9; +const IN_173: usize = 9; +const OUT_173: usize = 9; +fn aiur_fn_173( + inp: [G; IN_173], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15639,15 +15736,15 @@ fn aiur_fn_172( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(109); @@ -15694,7 +15791,7 @@ fn aiur_fn_172( let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -15716,16 +15813,16 @@ fn aiur_fn_172( let __v_77: G = G::from_u64(1); let __v_78: G = G::from_u64(1); let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(1); let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = __r_arr[2]; @@ -15747,25 +15844,25 @@ fn aiur_fn_172( let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); let __v_112: G = G::from_u64(1); let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(1); let __v_117: G = G::from_u64(1); let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __r_arr[2]; @@ -15784,12 +15881,12 @@ fn aiur_fn_172( let __v_134: G = __r_arr[15]; let __v_135: G = __r_arr[16]; let __v_136: G = __r_arr[17]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; @@ -15976,29 +16073,29 @@ fn aiur_fn_172( let __v_324: G = (__v_309 + __v_323); let __v_325: G = (__v_307 + __v_324); let __v_326: G = (__v_149 + __v_325); - let __ret: [G; OUT_172] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; - if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 3; -const IN_173: usize = 3; -const OUT_173: usize = 2; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_174: usize = 3; +const IN_174: usize = 3; +const OUT_174: usize = 2; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_173] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16012,135 +16109,135 @@ fn aiur_fn_173( let __v_10: G = (__v_8 + __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 - __v_11); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_173] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_174: usize = 1; -const IN_174: usize = 1; -const OUT_174: usize = 1; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_175: usize = 1; +const IN_175: usize = 1; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_174] = [__v_1]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_1]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); - let __ret: [G; OUT_174] = [__v_1]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_1]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); - let __ret: [G; OUT_174] = [__v_4]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_4]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_175: usize = 3; -const IN_175: usize = 3; -const OUT_175: usize = 2; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_176: usize = 3; +const IN_176: usize = 3; +const OUT_176: usize = 2; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); - let __ret: [G; OUT_175] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 1; -const IN_176: usize = 1; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_177: usize = 1; +const IN_177: usize = 1; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_176] = [__v_1]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_177] = [__v_1]; + if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); - let __ret: [G; OUT_176] = [__v_5]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_177] = [__v_5]; + if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_177: usize = 3; -const IN_177: usize = 3; -const OUT_177: usize = 8; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_178: usize = 3; +const IN_178: usize = 3; +const OUT_178: usize = 8; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); @@ -16251,21 +16348,21 @@ fn aiur_fn_177( let __v_92: G = G::from_u64(0); let __v_93: G = (__v_92 - __v_8); let __v_94: G = (__v_93 * __v_83); - let __ret: [G; OUT_177] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_178] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; + if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_178: usize = 24; -const IN_178: usize = 24; -const OUT_178: usize = 1; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_179: usize = 24; +const IN_179: usize = 24; +const OUT_179: usize = 1; +fn aiur_fn_179( + inp: [G; IN_179], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16293,52 +16390,52 @@ fn aiur_fn_178( let __v_23: G = inp[23]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_bool((__v_24 == G::ZERO)); let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; if (__v_27 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; if (__v_28 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; if (__v_29 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(1); - let __ret: [G; OUT_178] = [__v_32]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_179] = [__v_32]; + if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_179: usize = 6; -const IN_179: usize = 6; -const OUT_179: usize = 2; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_180: usize = 6; +const IN_180: usize = 6; +const OUT_180: usize = 2; +fn aiur_fn_180( + inp: [G; IN_180], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16356,21 +16453,21 @@ fn aiur_fn_179( let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); - let __ret: [G; OUT_179] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_180: usize = 4; -const IN_180: usize = 4; -const OUT_180: usize = 2; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_181: usize = 4; +const IN_181: usize = 4; +const OUT_181: usize = 2; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16388,21 +16485,21 @@ fn aiur_fn_180( let __v_13: G = (__v_11 + __v_12); let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); - let __ret: [G; OUT_180] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_181: usize = 1; -const IN_181: usize = 1; -const OUT_181: usize = 1; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_182: usize = 1; +const IN_182: usize = 1; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -16415,8 +16512,8 @@ fn aiur_fn_181( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_7]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_7]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16428,14 +16525,14 @@ fn aiur_fn_181( match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_13]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_13]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16450,15 +16547,15 @@ fn aiur_fn_181( }) } -const INPUT_SIZE_182: usize = 15; -const IN_182: usize = 15; -const OUT_182: usize = 2; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_183: usize = 15; +const IN_183: usize = 15; +const OUT_183: usize = 2; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16475,7 +16572,7 @@ fn aiur_fn_182( let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -16483,8 +16580,8 @@ fn aiur_fn_182( match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_182] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -16492,109 +16589,109 @@ fn aiur_fn_182( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_182] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_182] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_182] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 + __v_21); let __v_24: G = (__v_20 + __v_22); - let __ret: [G; OUT_182] = [__v_23, __v_24]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_23, __v_24]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 - __v_21); let __v_24: G = (__v_20 - __v_22); - let __ret: [G; OUT_182] = [__v_23, __v_24]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_23, __v_24]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); @@ -16605,20 +16702,20 @@ fn aiur_fn_182( let __v_28: G = (__v_19 * __v_22); let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); - let __ret: [G; OUT_182] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); let __v_22: G = (__v_21 - __v_19); let __v_23: G = G::from_u64(0); let __v_24: G = (__v_23 - __v_20); - let __ret: [G; OUT_182] = [__v_22, __v_24]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_22, __v_24]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16628,15 +16725,15 @@ fn aiur_fn_182( }) } -const INPUT_SIZE_183: usize = 19; -const IN_183: usize = 19; -const OUT_183: usize = 2; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_184: usize = 19; +const IN_184: usize = 19; +const OUT_184: usize = 2; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16663,22 +16760,22 @@ fn aiur_fn_183( let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_183] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_183] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16688,15 +16785,15 @@ fn aiur_fn_183( }) } -const INPUT_SIZE_184: usize = 8; -const IN_184: usize = 8; -const OUT_184: usize = 4; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_185: usize = 8; +const IN_185: usize = 8; +const OUT_185: usize = 4; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16752,21 +16849,21 @@ fn aiur_fn_184( let __v_51: G = (__v_15 + __v_33); let __v_52: G = (__v_38 + __v_46); let __v_53: G = (__v_41 + __v_49); - let __ret: [G; OUT_184] = [__v_50, __v_51, __v_52, __v_53]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_50, __v_51, __v_52, __v_53]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_185: usize = 19; -const IN_185: usize = 19; -const OUT_185: usize = 4; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_186: usize = 19; +const IN_186: usize = 19; +const OUT_186: usize = 4; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16797,28 +16894,28 @@ fn aiur_fn_185( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_185] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = (__v_26 + __v_30); let __v_33: G = (__v_27 + __v_31); - let __ret: [G; OUT_185] = [__v_32, __v_33, __v_28, __v_29]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_32, __v_33, __v_28, __v_29]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16828,15 +16925,15 @@ fn aiur_fn_185( }) } -const INPUT_SIZE_186: usize = 44; -const IN_186: usize = 44; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_187: usize = 44; +const IN_187: usize = 44; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16889,14 +16986,14 @@ fn aiur_fn_186( let __v_47: G = __loaded[3]; match __v_44.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_186] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -16905,10 +17002,10 @@ fn aiur_fn_186( let __v_53: G = (__v_49 + __v_23); let __v_54: G = (__v_50 + __v_24); let __v_55: G = (__v_51 + __v_25); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -16933,7 +17030,7 @@ fn aiur_fn_186( let __v_79: G = (__v_77 + __v_78); let __v_80: G = (__v_60 + __v_76); let __v_81: G = (__v_61 + __v_79); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; @@ -16944,23 +17041,23 @@ fn aiur_fn_186( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __v_91: G = __r_arr[1]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_7 + __v_92); let __v_94: G = (__v_7 + __v_93); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = (__v_98 + __v_18); let __v_101: G = (__v_99 + __v_19); let __v_102: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = (__v_103 + __v_20); @@ -16969,23 +17066,23 @@ fn aiur_fn_186( let __v_108: G = (__v_101 - __v_91); let __v_109: G = (__v_105 - __v_95); let __v_110: G = (__v_106 - __v_96); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; let __v_113: G = __r_arr[2]; let __v_114: G = __r_arr[3]; let __v_115: G = (__v_111 - __v_70); let __v_116: G = (__v_112 - __v_71); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; let __v_119: G = (__v_113 - __v_80); let __v_120: G = (__v_114 - __v_81); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_121, __v_122]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_121, __v_122]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16994,44 +17091,44 @@ fn aiur_fn_186( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); let __v_95: G = (__v_7 + __v_94); let __v_96: G = (__v_7 + __v_95); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = G::from_u64(2); let __v_100: G = (__v_7 + __v_99); let __v_101: G = (__v_7 + __v_100); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = G::from_u64(3); let __v_105: G = (__v_7 + __v_104); let __v_106: G = (__v_7 + __v_105); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = __r_arr[1]; let __v_109: G = (__v_102 - __v_92); let __v_110: G = (__v_103 - __v_93); let __v_111: G = (__v_107 - __v_97); let __v_112: G = (__v_108 - __v_98); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; let __v_115: G = __r_arr[2]; let __v_116: G = __r_arr[3]; let __v_117: G = (__v_113 - __v_70); let __v_118: G = (__v_114 - __v_71); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = (__v_115 - __v_80); let __v_122: G = (__v_116 - __v_81); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; let __v_125: G = G::from_u64(1); @@ -17046,11 +17143,11 @@ fn aiur_fn_186( let __v_134: G = G::from_u64(0); let __v_135: G = G::from_u64(0); let __v_136: G = G::from_u64(0); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_137, __v_138]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_137, __v_138]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17058,11 +17155,11 @@ fn aiur_fn_186( let __v_92: G = (__v_5 + __v_91); let __v_93: G = G::from_u64(1); let __v_94: G = (__v_8 - __v_93); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_95, __v_96]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_95, __v_96]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -17078,15 +17175,15 @@ fn aiur_fn_186( }) } -const INPUT_SIZE_187: usize = 28; -const IN_187: usize = 28; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_188: usize = 28; +const IN_188: usize = 28; +const OUT_188: usize = 2; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17118,7 +17215,7 @@ fn aiur_fn_187( let __v_27: G = inp[27]; let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); @@ -17175,42 +17272,42 @@ fn aiur_fn_187( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = (__v_83 - __v_86); let __v_89: G = (__v_84 - __v_87); let __v_90: G = (__v_88 + __v_55); let __v_91: G = (__v_89 + __v_58); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = (__v_95 - __v_98); let __v_101: G = (__v_96 - __v_99); let __v_102: G = (__v_100 + __v_74); let __v_103: G = (__v_101 + __v_77); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_104, __v_105]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_104, __v_105]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(1); @@ -17221,11 +17318,11 @@ fn aiur_fn_187( let __v_90: G = G::from_u64(0); let __v_91: G = G::from_u64(0); let __v_92: G = G::from_u64(0); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_93, __v_94]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_93, __v_94]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17235,15 +17332,15 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 8; -const IN_188: usize = 8; -const OUT_188: usize = 1; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_189: usize = 8; +const IN_189: usize = 8; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17280,21 +17377,21 @@ fn aiur_fn_188( let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_34]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_34]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_189: usize = 5; -const IN_189: usize = 5; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_190: usize = 5; +const IN_190: usize = 5; +const OUT_190: usize = 2; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17310,8 +17407,8 @@ fn aiur_fn_189( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_189] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -17331,13 +17428,13 @@ fn aiur_fn_189( let __v_22: G = (__v_3 * __v_2); let __v_23: G = (__v_4 * __v_1); let __v_24: G = (__v_22 + __v_23); - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = (__v_13 + __v_25); let __v_28: G = (__v_16 + __v_26); - let __ret: [G; OUT_189] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17347,145 +17444,145 @@ fn aiur_fn_189( }) } -const INPUT_SIZE_190: usize = 1; -const IN_190: usize = 1; -const OUT_190: usize = 1; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_191: usize = 1; +const IN_191: usize = 1; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); - let __ret: [G; OUT_190] = [__v_1]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_1]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 4; -const IN_191: usize = 4; -const OUT_191: usize = 2; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_192: usize = 4; +const IN_192: usize = 4; +const OUT_192: usize = 2; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17499,8 +17596,8 @@ fn aiur_fn_191( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -17512,21 +17609,21 @@ fn aiur_fn_191( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_191] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17541,15 +17638,15 @@ fn aiur_fn_191( }) } -const INPUT_SIZE_192: usize = 20; -const IN_192: usize = 20; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_193: usize = 20; +const IN_193: usize = 20; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17583,37 +17680,37 @@ fn aiur_fn_192( match __v_20.as_canonical_u64() { 1u64 => { let __v_28: G = G::from_u64(1); - let __ret: [G; OUT_192] = [__v_28]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_28]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() { @@ -17638,13 +17735,13 @@ fn aiur_fn_192( break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -17660,14 +17757,14 @@ fn aiur_fn_192( }; let __v_44: G = __mc_out___mc_0[0]; let __v_45: G = __mc_out___mc_0[1]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(0); let __v_50: G = (__v_46 - __v_48); let __v_51: G = (__v_47 - __v_49); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = g_inverse_value(__v_52); let __v_54: G = (__v_52 * __v_53); @@ -17805,9 +17902,9 @@ fn aiur_fn_192( let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_166: G = __r_arr[0]; let __v_167: G = (__v_165 * __v_166); let __v_168: G = g_inverse_value(__v_167); @@ -17826,7 +17923,7 @@ fn aiur_fn_192( } let __v_176: G = G::from_u64(0); let __v_177: G = G::from_u64(0); - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; let __v_179: G = __r_arr[1]; let __v_180: G = G::from_u64(0); @@ -17883,40 +17980,40 @@ fn aiur_fn_192( let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() { 1u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; let __v_235: G = __r_arr[1]; let __v_236: G = (__v_231 - __v_234); let __v_237: G = (__v_232 - __v_235); let __v_238: G = (__v_236 + __v_203); let __v_239: G = (__v_237 + __v_206); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = G::from_u64(1); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_246: G = __r_arr[0]; let __v_247: G = __r_arr[1]; let __v_248: G = (__v_243 - __v_246); let __v_249: G = (__v_244 - __v_247); let __v_250: G = (__v_248 + __v_222); let __v_251: G = (__v_249 + __v_225); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_252: G = __r_arr[0]; let __v_253: G = __r_arr[1]; break '__mc_1 [__v_252, __v_253]; }, 0u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = G::from_u64(0); let __v_233: G = G::from_u64(1); @@ -17927,7 +18024,7 @@ fn aiur_fn_192( let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); let __v_240: G = G::from_u64(0); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_241: G = __r_arr[0]; let __v_242: G = __r_arr[1]; break '__mc_1 [__v_241, __v_242]; @@ -17939,19 +18036,19 @@ fn aiur_fn_192( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_232: G = __r_arr[0]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_236: G = __r_arr[0]; let __v_237: G = __r_arr[1]; let __v_238: G = G::from_u64(1); let __v_239: G = G::from_u64(0); - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = (__v_230 * __v_134); @@ -17968,7 +18065,7 @@ fn aiur_fn_192( if (__v_251 != __v_252) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_253: G = __r_arr[0]; let __v_254: G = (__v_253 - __v_29); let __v_255: G = G::from_bool((__v_254 == G::ZERO)); @@ -17987,10 +18084,10 @@ fn aiur_fn_192( } let __v_263: G = G::from_u64(1); let __v_264: G = (__v_9 + __v_263); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_265: G = __r_arr[0]; - let __ret: [G; OUT_192] = [__v_265]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_265]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18002,15 +18099,15 @@ fn aiur_fn_192( }) } -const INPUT_SIZE_193: usize = 3; -const IN_193: usize = 3; -const OUT_193: usize = 2; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_194: usize = 3; +const IN_194: usize = 3; +const OUT_194: usize = 2; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18030,8 +18127,8 @@ fn aiur_fn_193( 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_193] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -18057,7 +18154,7 @@ fn aiur_fn_193( let __v_32: G = (__v_14 + __v_31); let __v_33: G = (__v_4 + __v_32); let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); @@ -18070,8 +18167,8 @@ fn aiur_fn_193( let __v_44: G = (__v_42 + __v_43); let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); - let __ret: [G; OUT_193] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18081,15 +18178,15 @@ fn aiur_fn_193( }) } -const INPUT_SIZE_194: usize = 7; -const IN_194: usize = 7; -const OUT_194: usize = 2; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_195: usize = 7; +const IN_195: usize = 7; +const OUT_195: usize = 2; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18104,12 +18201,12 @@ fn aiur_fn_194( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_194] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); @@ -18139,11 +18236,11 @@ fn aiur_fn_194( let __v_30: G = (__v_29 * __v_19); let __v_31: G = (__v_0 + __v_27); let __v_32: G = (__v_1 + __v_30); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __ret: [G; OUT_194] = [__v_33, __v_34]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_33, __v_34]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18153,15 +18250,15 @@ fn aiur_fn_194( }) } -const INPUT_SIZE_195: usize = 38; -const IN_195: usize = 38; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_196: usize = 38; +const IN_196: usize = 38; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18207,9 +18304,9 @@ fn aiur_fn_195( _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { @@ -18229,15 +18326,15 @@ fn aiur_fn_195( } }; let __v_40: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_17, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_17, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_13, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_12, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_12, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_7, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_7, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(109); @@ -18284,7 +18381,7 @@ fn aiur_fn_195( let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; @@ -18306,16 +18403,16 @@ fn aiur_fn_195( let __v_109: G = G::from_u64(1); let __v_110: G = G::from_u64(1); let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_107, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_107, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); let __v_116: G = G::from_u64(1); let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_114, __v_117]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_114, __v_117]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __r_arr[2]; @@ -18337,25 +18434,25 @@ fn aiur_fn_195( let __v_136: G = G::from_u64(1); let __v_137: G = G::from_u64(1); let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_140: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_134, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_134, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_141, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_141, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_142: G = __r_arr[0]; let __v_143: G = G::from_u64(1); let __v_144: G = G::from_u64(1); let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_16, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_142, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_142, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_147, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_147, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; @@ -18374,12 +18471,12 @@ fn aiur_fn_195( let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_167, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_167, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_169, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_169, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __v_174: G = __r_arr[1]; let __v_175: G = __r_arr[2]; @@ -18568,17 +18665,17 @@ fn aiur_fn_195( let __v_358: G = (__v_181 + __v_357); let __v_359: G = G::from_u64(0); let __v_360: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_361: G = __r_arr[0]; let __v_362: G = __r_arr[1]; let __v_363: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); let __v_368: G = G::from_u64(1); @@ -18588,7 +18685,7 @@ fn aiur_fn_195( break '__mc_1 [__v_369]; }, 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_33, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_33, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_370: G = __r_arr[0]; break '__mc_1 [__v_370]; }, @@ -18598,18 +18695,18 @@ fn aiur_fn_195( } }; let __v_370: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_31, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_31, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_371: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_35, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_35, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_372: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_34, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_34, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_373: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_189, __v_373]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_189, __v_373]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_374: G = __r_arr[0]; let __v_375: G = G::from_u64(1); let __v_376: G = G::from_u64(1); let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_374, __v_377]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_374, __v_377]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_378: G = __r_arr[0]; let __v_379: G = __r_arr[1]; let __v_380: G = __r_arr[2]; @@ -18670,28 +18767,28 @@ fn aiur_fn_195( let __v_435: G = (__v_420 + __v_434); let __v_436: G = (__v_418 + __v_435); let __v_437: G = (__v_386 + __v_436); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_438: G = __r_arr[0]; let __v_439: G = __r_arr[1]; let __v_440: G = G::from_u64(1); let __v_441: G = G::from_u64(1); let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_22, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_443: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_439, __v_443]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_439, __v_443]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_444: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_444, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_444, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_445: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_446: G = __r_arr[0]; let __v_447: G = __r_arr[1]; let __v_448: G = (__v_366 + __v_0); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_449: G = __r_arr[0]; let __v_450: G = G::from_u64(0); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_451: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_452: G = __r_arr[0]; let __v_453: G = G::from_u64(0); if (__v_1 != __v_453) { @@ -18705,15 +18802,15 @@ fn aiur_fn_195( if (__v_3 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; let __v_457: G = G::from_u64(1); if (__v_456 != __v_457) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_458: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_459: G = __r_arr[0]; let __v_460: G = (__v_458 - __v_459); let __v_461: G = G::from_bool((__v_460 == G::ZERO)); @@ -18721,9 +18818,9 @@ fn aiur_fn_195( if (__v_461 != __v_462) { return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; let __v_465: G = (__v_463 - __v_464); let __v_466: G = G::from_bool((__v_465 == G::ZERO)); @@ -18731,7 +18828,7 @@ fn aiur_fn_195( if (__v_466 != __v_467) { return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_468: G = __r_arr[0]; let __v_469: G = (__v_468 - __v_366); let __v_470: G = G::from_bool((__v_469 == G::ZERO)); @@ -18739,16 +18836,16 @@ fn aiur_fn_195( if (__v_470 != __v_471) { return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_472: G = __r_arr[0]; let __v_473: G = G::from_u64(3); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_474: G = __r_arr[0]; let __v_475: G = (__v_473 + __v_474); if (__v_472 != __v_475) { return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_476: G = __r_arr[0]; let __v_477: G = (__v_476 - __v_366); let __v_478: G = G::from_bool((__v_477 == G::ZERO)); @@ -18756,7 +18853,7 @@ fn aiur_fn_195( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_480: G = __r_arr[0]; let __v_481: G = G::from_u64(1); if (__v_480 != __v_481) { @@ -18768,17 +18865,17 @@ fn aiur_fn_195( if (__v_483 != __v_484) { return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_485: G = __r_arr[0]; let __v_486: G = G::from_u64(1); if (__v_485 != __v_486) { return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); } let __v_487: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_488: G = __r_arr[0]; - let __ret: [G; OUT_195] = [__v_488]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_488]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18793,15 +18890,15 @@ fn aiur_fn_195( }) } -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_197], 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 }; @@ -18811,8 +18908,8 @@ fn aiur_fn_196( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_196] = [__v_4]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_4]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -18823,10 +18920,10 @@ fn aiur_fn_196( if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_196] = [__v_8]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_8]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18836,15 +18933,15 @@ fn aiur_fn_196( }) } -const INPUT_SIZE_197: usize = 2; -const IN_197: usize = 2; -const OUT_197: usize = 1; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_198: usize = 2; +const IN_198: usize = 2; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18862,8 +18959,8 @@ fn aiur_fn_197( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_12]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_12]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -18875,19 +18972,19 @@ fn aiur_fn_197( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_197] = [__v_13]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_13]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_15]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_15]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18904,15 +19001,15 @@ fn aiur_fn_197( }) } -const INPUT_SIZE_198: usize = 2; -const IN_198: usize = 2; -const OUT_198: usize = 1; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_199: usize = 2; +const IN_199: usize = 2; +const OUT_199: usize = 1; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18926,8 +19023,8 @@ fn aiur_fn_198( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_8]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_8]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -18939,19 +19036,19 @@ fn aiur_fn_198( 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_198] = [__v_9]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_11]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_11]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18968,38 +19065,38 @@ fn aiur_fn_198( }) } -const INPUT_SIZE_199: usize = 1; -const IN_199: usize = 1; -const OUT_199: usize = 2; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_199] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_200: usize = 2; -const IN_200: usize = 2; -const OUT_200: usize = 2; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_201: usize = 2; +const IN_201: usize = 2; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19008,64 +19105,64 @@ fn aiur_fn_200( 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_200] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 2; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_202: usize = 1; +const IN_202: usize = 1; +const OUT_202: usize = 2; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_201] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_202: usize = 2; -const IN_202: usize = 2; -const OUT_202: usize = 2; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_203: usize = 2; +const IN_203: usize = 2; +const OUT_203: usize = 2; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19074,8 +19171,8 @@ fn aiur_fn_202( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19091,28 +19188,28 @@ fn aiur_fn_202( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_16, __v_14]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_16, __v_14]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_203: usize = 16; -const IN_203: usize = 16; -const OUT_203: usize = 0; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_204: usize = 16; +const IN_204: usize = 16; +const OUT_204: usize = 0; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19417,7 +19514,7 @@ fn aiur_fn_203( let __v_263: G = __r_arr[1]; let __v_264: G = G::from_u64(0); let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_245, __v_265]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_245, __v_265]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_266: G = __r_arr[0]; let __v_267: G = G::from_u64(2); let __v_268: G = G::from_u64(0); @@ -19515,34 +19612,34 @@ fn aiur_fn_203( let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_356: G = __r_arr[0]; let __v_357: G = __r_arr[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_357, __v_356]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_357, __v_356]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_358: G = __r_arr[0]; let __v_359: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_360: G = __r_arr[0]; let __v_361: G = G::from_bool((__v_360 == G::ZERO)); let __v_362: G = G::from_u64(0); if (__v_361 != __v_362) { return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_363: G = __r_arr[0]; if (__v_363 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; if (__v_364 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; if (__v_365 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); if (__v_366 != __v_367) { @@ -19560,9 +19657,9 @@ fn aiur_fn_203( _ => { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_256, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_256, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_361: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_262, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_262, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_362: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { @@ -19582,15 +19679,15 @@ fn aiur_fn_203( } }; let __v_363: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_34, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_34, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_367: G = __r_arr[0]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_266, __v_367]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_266, __v_367]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_368: G = __r_arr[0]; let __v_369: G = G::from_u64(0); let __v_370: G = G::from_u64(109); @@ -19637,7 +19734,7 @@ fn aiur_fn_203( let __v_411: G = G::from_u64(1); let __v_412: G = G::from_u64(1); let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_410, __v_413]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_410, __v_413]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_414: G = __r_arr[0]; let __v_415: G = __r_arr[1]; let __v_416: G = __r_arr[2]; @@ -19659,16 +19756,16 @@ fn aiur_fn_203( let __v_432: G = G::from_u64(1); let __v_433: G = G::from_u64(1); let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_435: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_436: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_430, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_430, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_437: G = __r_arr[0]; let __v_438: G = G::from_u64(1); let __v_439: G = G::from_u64(1); let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_437, __v_440]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_437, __v_440]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_441: G = __r_arr[0]; let __v_442: G = __r_arr[1]; let __v_443: G = __r_arr[2]; @@ -19690,25 +19787,25 @@ fn aiur_fn_203( let __v_459: G = G::from_u64(1); let __v_460: G = G::from_u64(1); let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_462: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_457, __v_463]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_457, __v_463]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_464, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_464, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_465: G = __r_arr[0]; let __v_466: G = G::from_u64(1); let __v_467: G = G::from_u64(1); let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_30, __v_468]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30, __v_468]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_469: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_465, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_465, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_470: G = __r_arr[0]; let __v_471: G = G::from_u64(1); let __v_472: G = G::from_u64(1); let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_470, __v_473]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_470, __v_473]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_474: G = __r_arr[0]; let __v_475: G = __r_arr[1]; let __v_476: G = __r_arr[2]; @@ -19727,12 +19824,12 @@ fn aiur_fn_203( let __v_489: G = __r_arr[15]; let __v_490: G = __r_arr[16]; let __v_491: G = __r_arr[17]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_490, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_490, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; let __v_493: G = G::from_u64(1); let __v_494: G = G::from_u64(1); let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_492, __v_495]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_492, __v_495]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_496: G = __r_arr[0]; let __v_497: G = __r_arr[1]; let __v_498: G = __r_arr[2]; @@ -19921,17 +20018,17 @@ fn aiur_fn_203( let __v_681: G = (__v_504 + __v_680); let __v_682: G = G::from_u64(0); let __v_683: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_684: G = __r_arr[0]; let __v_685: G = __r_arr[1]; let __v_686: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_687: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_688: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_689: G = __r_arr[0]; let __v_690: G = G::from_u64(1); let __v_691: G = G::from_u64(1); @@ -19941,7 +20038,7 @@ fn aiur_fn_203( break '__mc_3 [__v_692]; }, 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_64, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_64, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_693: G = __r_arr[0]; break '__mc_3 [__v_693]; }, @@ -19951,18 +20048,18 @@ fn aiur_fn_203( } }; let __v_693: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_61, __v_693]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_61, __v_693]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_694: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_68, __v_694]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_68, __v_694]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_695: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_66, __v_695]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_66, __v_695]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_696: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_512, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_512, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_697: G = __r_arr[0]; let __v_698: G = G::from_u64(1); let __v_699: G = G::from_u64(1); let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_697, __v_700]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_697, __v_700]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_701: G = __r_arr[0]; let __v_702: G = __r_arr[1]; let __v_703: G = __r_arr[2]; @@ -20023,28 +20120,28 @@ fn aiur_fn_203( let __v_758: G = (__v_743 + __v_757); let __v_759: G = (__v_741 + __v_758); let __v_760: G = (__v_709 + __v_759); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_761: G = __r_arr[0]; let __v_762: G = __r_arr[1]; let __v_763: G = G::from_u64(1); let __v_764: G = G::from_u64(1); let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_50, __v_765]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_50, __v_765]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_766: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_762, __v_766]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_762, __v_766]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_767: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_767, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_767, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_768: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_769: G = __r_arr[0]; let __v_770: G = __r_arr[1]; let __v_771: G = (__v_689 + __v_159); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_772: G = __r_arr[0]; let __v_773: G = G::from_u64(0); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_774: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_775: G = __r_arr[0]; let __v_776: G = G::from_u64(0); if (__v_169 != __v_776) { @@ -20058,15 +20155,15 @@ fn aiur_fn_203( if (__v_189 != __v_778) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_779: G = __r_arr[0]; let __v_780: G = G::from_u64(1); if (__v_779 != __v_780) { return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_781: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_256]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_256]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_782: G = __r_arr[0]; let __v_783: G = (__v_781 - __v_782); let __v_784: G = G::from_bool((__v_783 == G::ZERO)); @@ -20074,9 +20171,9 @@ fn aiur_fn_203( if (__v_784 != __v_785) { return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_786: G = __r_arr[0]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_787: G = __r_arr[0]; let __v_788: G = (__v_786 - __v_787); let __v_789: G = G::from_bool((__v_788 == G::ZERO)); @@ -20084,7 +20181,7 @@ fn aiur_fn_203( if (__v_789 != __v_790) { return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_791: G = __r_arr[0]; let __v_792: G = (__v_791 - __v_689); let __v_793: G = G::from_bool((__v_792 == G::ZERO)); @@ -20092,16 +20189,16 @@ fn aiur_fn_203( if (__v_793 != __v_794) { return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_795: G = __r_arr[0]; let __v_796: G = G::from_u64(3); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_797: G = __r_arr[0]; let __v_798: G = (__v_796 + __v_797); if (__v_795 != __v_798) { return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_799: G = __r_arr[0]; let __v_800: G = (__v_799 - __v_689); let __v_801: G = G::from_bool((__v_800 == G::ZERO)); @@ -20109,7 +20206,7 @@ fn aiur_fn_203( if (__v_801 != __v_802) { return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_803: G = __r_arr[0]; let __v_804: G = G::from_u64(1); if (__v_803 != __v_804) { @@ -20121,14 +20218,14 @@ fn aiur_fn_203( if (__v_806 != __v_807) { return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_808: G = __r_arr[0]; let __v_809: G = G::from_u64(1); if (__v_808 != __v_809) { return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); } let __v_810: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_811: G = __r_arr[0]; break '__mc_1 [__v_811]; }, @@ -20377,25 +20474,25 @@ fn aiur_fn_203( if (__v_361 != __v_518) { return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_203] = []; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = []; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_204: usize = 2; -const IN_204: usize = 2; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_205: usize = 2; +const IN_205: usize = 2; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __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]; @@ -20403,8 +20500,8 @@ fn aiur_fn_204( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_204] = [__v_4]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_205] = [__v_4]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20414,15 +20511,15 @@ fn aiur_fn_204( }) } -const INPUT_SIZE_205: usize = 1; -const IN_205: usize = 1; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_206: usize = 1; +const IN_206: usize = 1; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_206], 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 }; @@ -20432,17 +20529,17 @@ fn aiur_fn_205( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_205] = [__v_4]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_206] = [__v_4]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_205] = [__v_6]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_206] = [__v_6]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20452,15 +20549,15 @@ fn aiur_fn_205( }) } -const INPUT_SIZE_206: usize = 1; -const IN_206: usize = 1; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_207: usize = 1; +const IN_207: usize = 1; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -20471,17 +20568,17 @@ fn aiur_fn_206( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_206] = [__v_5]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_5]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_5 + __v_6); - let __ret: [G; OUT_206] = [__v_7]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_7]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20491,15 +20588,15 @@ fn aiur_fn_206( }) } -const INPUT_SIZE_207: usize = 2; -const IN_207: usize = 2; -const OUT_207: usize = 1; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_208: usize = 2; +const IN_208: usize = 2; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -20509,17 +20606,17 @@ fn aiur_fn_207( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_207] = [__v_1]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_208] = [__v_1]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_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_207] = [__v_7]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_208] = [__v_7]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20529,15 +20626,15 @@ fn aiur_fn_207( }) } -const INPUT_SIZE_208: usize = 1; -const IN_208: usize = 1; -const OUT_208: usize = 1; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_209: usize = 1; +const IN_209: usize = 1; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_209], 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 }; @@ -20550,17 +20647,17 @@ fn aiur_fn_208( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_208] = [__v_7]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_7]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_208] = [__v_9]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_9]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20570,15 +20667,15 @@ fn aiur_fn_208( }) } -const INPUT_SIZE_209: usize = 1; -const IN_209: usize = 1; -const OUT_209: usize = 1; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_210: usize = 1; +const IN_210: usize = 1; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; @@ -20592,17 +20689,17 @@ fn aiur_fn_209( match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_209] = [__v_8]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_8]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); - let __ret: [G; OUT_209] = [__v_10]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_10]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20612,15 +20709,15 @@ fn aiur_fn_209( }) } -const INPUT_SIZE_210: usize = 1; -const IN_210: usize = 1; -const OUT_210: usize = 1; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_211: usize = 1; +const IN_211: usize = 1; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: [G; IN_211], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = 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 }; @@ -20637,17 +20734,17 @@ fn aiur_fn_210( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_210] = [__v_11]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_11]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_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_210] = [__v_13]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_13]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20657,19 +20754,19 @@ fn aiur_fn_210( }) } -const INPUT_SIZE_211: usize = 2; -const IN_211: usize = 2; -const OUT_211: usize = 4; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_212: usize = 2; +const IN_212: usize = 2; +const OUT_212: usize = 4; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -20680,8 +20777,8 @@ fn aiur_fn_211( let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_211] = [__v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_212] = [__v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20691,15 +20788,15 @@ fn aiur_fn_211( }) } -const INPUT_SIZE_212: usize = 1; -const IN_212: usize = 1; -const OUT_212: usize = 1; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_213: usize = 1; +const IN_213: usize = 1; +const OUT_213: usize = 1; +fn aiur_fn_213( + inp: [G; IN_213], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = 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 }; @@ -20709,14 +20806,14 @@ fn aiur_fn_212( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_212] = [__v_4]; - if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_213] = [__v_4]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_212] = [__v_4]; - if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_213] = [__v_4]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20726,19 +20823,19 @@ fn aiur_fn_212( }) } -const INPUT_SIZE_213: usize = 2; -const IN_213: usize = 2; -const OUT_213: usize = 2; -fn aiur_fn_213( - inp: [G; IN_213], +const INPUT_SIZE_214: usize = 2; +const IN_214: usize = 2; +const OUT_214: usize = 2; +fn aiur_fn_214( + inp: [G; IN_214], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -20747,8 +20844,8 @@ fn aiur_fn_213( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_213] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_214] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20758,15 +20855,15 @@ fn aiur_fn_213( }) } -const INPUT_SIZE_214: usize = 2; -const IN_214: usize = 2; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_215: usize = 2; +const IN_215: usize = 2; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -20783,17 +20880,17 @@ fn aiur_fn_214( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_214] = [__v_1]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_1]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_214] = [__v_14]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_14]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20803,15 +20900,15 @@ fn aiur_fn_214( }) } -const INPUT_SIZE_215: usize = 1; -const IN_215: usize = 1; -const OUT_215: usize = 1; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_216: usize = 1; +const IN_216: usize = 1; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -20823,17 +20920,17 @@ fn aiur_fn_215( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_215] = [__v_6]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_6]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_215] = [__v_8]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_8]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20843,28 +20940,28 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 2; -const IN_216: usize = 2; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_216] = [__v_0]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_0]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -20872,8 +20969,8 @@ fn aiur_fn_216( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_216] = [__v_7]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_7]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20885,15 +20982,15 @@ fn aiur_fn_216( }) } -const INPUT_SIZE_217: usize = 1; -const IN_217: usize = 1; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_218: usize = 1; +const IN_218: usize = 1; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; @@ -20908,17 +21005,17 @@ fn aiur_fn_217( match __v_1.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_217] = [__v_9]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_9]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_9 + __v_10); - let __ret: [G; OUT_217] = [__v_11]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_11]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20928,28 +21025,28 @@ fn aiur_fn_217( }) } -const INPUT_SIZE_218: usize = 2; -const IN_218: usize = 2; -const OUT_218: usize = 1; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_219: usize = 2; +const IN_219: usize = 2; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_218] = [__v_0]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_0]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -20958,8 +21055,8 @@ fn aiur_fn_218( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_218] = [__v_8]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_8]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20971,28 +21068,28 @@ fn aiur_fn_218( }) } -const INPUT_SIZE_219: usize = 2; -const IN_219: usize = 2; -const OUT_219: usize = 1; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_220: usize = 2; +const IN_220: usize = 2; +const OUT_220: usize = 1; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_219] = [__v_0]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_0]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -21003,8 +21100,8 @@ fn aiur_fn_219( let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_219] = [__v_10]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22123,6 +22220,11 @@ pub(crate) fn execute_generated( let __out = aiur_fn_219(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 220u64 => { + let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_220(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From b3b7919d856c27f1b1e8a0a4202dac7d932d8ea0 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 2 Sep 2026 17:46:24 +0000 Subject: [PATCH 6/6] Bump multi-stark after main rebase --- Cargo.lock | 2 +- Cargo.toml | 2 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 29615 +++++++++++++------------ 3 files changed, 15030 insertions(+), 14589 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ef7bf2676..be0169f6b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2104,7 +2104,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=8f3c50d8f48aad2efc90c24729c441677b296fe2#8f3c50d8f48aad2efc90c24729c441677b296fe2" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3#a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3" dependencies = [ "bincode", "itertools 0.14.0", diff --git a/Cargo.toml b/Cargo.toml index 3c5b0be03..273dd4451 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,7 +56,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "8f3c50d8f48aad2efc90c24729c441677b296fe2" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index f2e10bc6b..a0965d7ee 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -5229,7 +5229,7 @@ fn aiur_fn_29( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __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]; @@ -5410,10 +5410,10 @@ fn aiur_fn_29( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __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]; @@ -7948,7 +7948,7 @@ fn aiur_fn_34( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7969,7 +7969,7 @@ fn aiur_fn_34( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8037,7 +8037,7 @@ fn aiur_fn_34( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8047,7 +8047,7 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; @@ -8056,7 +8056,7 @@ fn aiur_fn_34( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8066,7 +8066,7 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; @@ -8075,7 +8075,7 @@ fn aiur_fn_34( return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8085,7 +8085,7 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; @@ -8481,15 +8481,180 @@ fn aiur_fn_39( }) } -const INPUT_SIZE_40: usize = 18; -const IN_40: usize = 18; -const OUT_40: usize = 8; +const INPUT_SIZE_40: usize = 2; +const IN_40: usize = 2; +const OUT_40: usize = 1; fn aiur_fn_40( inp: [G; IN_40], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_40] = [__v_4]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_40] = [__v_4]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_40] = [__v_4]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(3); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_40] = [__v_4]; + if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_41: usize = 3; +const IN_41: usize = 3; +const OUT_41: usize = 1; +fn aiur_fn_41( + inp: [G; IN_41], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_41], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(4); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(5); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(2); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(6); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(3); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(7); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_41] = [__v_5]; + if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_42: usize = 18; +const IN_42: usize = 18; +const OUT_42: usize = 8; +fn aiur_fn_42( + inp: [G; IN_42], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8530,7 +8695,7 @@ fn aiur_fn_40( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8548,8 +8713,8 @@ fn aiur_fn_40( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8561,23 +8726,23 @@ fn aiur_fn_40( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_41: usize = 18; -const IN_41: usize = 18; -const OUT_41: usize = 8; -fn aiur_fn_41( - inp: [G; IN_41], +const INPUT_SIZE_43: usize = 18; +const IN_43: usize = 18; +const OUT_43: usize = 8; +fn aiur_fn_43( + inp: [G; IN_43], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_41], ExecError> { +) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8599,7 +8764,7 @@ fn aiur_fn_41( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8618,7 +8783,7 @@ fn aiur_fn_41( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8636,8 +8801,8 @@ fn aiur_fn_41( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8649,23 +8814,23 @@ fn aiur_fn_41( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_42: usize = 18; -const IN_42: usize = 18; -const OUT_42: usize = 8; -fn aiur_fn_42( - inp: [G; IN_42], +const INPUT_SIZE_44: usize = 18; +const IN_44: usize = 18; +const OUT_44: usize = 8; +fn aiur_fn_44( + inp: [G; IN_44], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_42], ExecError> { +) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8687,7 +8852,7 @@ fn aiur_fn_42( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8706,7 +8871,7 @@ fn aiur_fn_42( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8724,8 +8889,8 @@ fn aiur_fn_42( let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8737,23 +8902,23 @@ fn aiur_fn_42( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_43: usize = 19; -const IN_43: usize = 19; -const OUT_43: usize = 1; -fn aiur_fn_43( - inp: [G; IN_43], +const INPUT_SIZE_45: usize = 19; +const IN_45: usize = 19; +const OUT_45: usize = 1; +fn aiur_fn_45( + inp: [G; IN_45], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_43], ExecError> { +) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8816,32 +8981,32 @@ fn aiur_fn_43( let __v_54: G = __loaded[17]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_43] = [__v_56]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_56]; + if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_43] = [__v_19]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_19]; + if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_44: usize = 19; -const IN_44: usize = 19; -const OUT_44: usize = 1; -fn aiur_fn_44( - inp: [G; IN_44], +const INPUT_SIZE_46: usize = 19; +const IN_46: usize = 19; +const OUT_46: usize = 1; +fn aiur_fn_46( + inp: [G; IN_46], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_44], ExecError> { +) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8864,7 +9029,7 @@ fn aiur_fn_44( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8883,7 +9048,7 @@ fn aiur_fn_44( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8902,34 +9067,36 @@ fn aiur_fn_44( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_56]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_46] = [__v_57]; + if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_19]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_46] = [__v_19]; + if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_45: usize = 19; -const IN_45: usize = 19; -const OUT_45: usize = 1; -fn aiur_fn_45( - inp: [G; IN_45], +const INPUT_SIZE_47: usize = 19; +const IN_47: usize = 19; +const OUT_47: usize = 1; +fn aiur_fn_47( + inp: [G; IN_47], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_45], ExecError> { +) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8952,7 +9119,7 @@ fn aiur_fn_45( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8971,7 +9138,7 @@ fn aiur_fn_45( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8990,34 +9157,36 @@ fn aiur_fn_45( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_45] = [__v_56]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_47] = [__v_57]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_45] = [__v_19]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_19]; + if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_46: usize = 2; -const IN_46: usize = 2; -const OUT_46: usize = 1; -fn aiur_fn_46( - inp: [G; IN_46], +const INPUT_SIZE_48: usize = 2; +const IN_48: usize = 2; +const OUT_48: usize = 1; +fn aiur_fn_48( + inp: [G; IN_48], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_46], ExecError> { +) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9118,21 +9287,21 @@ fn aiur_fn_46( let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_96: G = G::from_u64(0); let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_46] = [__v_97]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_48] = [__v_97]; + if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_47: usize = 2; -const IN_47: usize = 2; -const OUT_47: usize = 1; -fn aiur_fn_47( - inp: [G; IN_47], +const INPUT_SIZE_49: usize = 2; +const IN_49: usize = 2; +const OUT_49: usize = 1; +fn aiur_fn_49( + inp: [G; IN_49], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_47], ExecError> { +) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9141,20 +9310,20 @@ fn aiur_fn_47( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9166,20 +9335,20 @@ fn aiur_fn_47( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(4); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9191,20 +9360,20 @@ fn aiur_fn_47( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(8); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); - let __ret: [G; OUT_47] = [__v_2]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_2]; + if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9219,15 +9388,15 @@ fn aiur_fn_47( }) } -const INPUT_SIZE_48: usize = 9; -const IN_48: usize = 9; -const OUT_48: usize = 8; -fn aiur_fn_48( - inp: [G; IN_48], +const INPUT_SIZE_50: usize = 9; +const IN_50: usize = 9; +const OUT_50: usize = 8; +fn aiur_fn_50( + inp: [G; IN_50], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_48], ExecError> { +) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9250,7 +9419,7 @@ fn aiur_fn_48( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9268,8 +9437,8 @@ fn aiur_fn_48( let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; - let __ret: [G; OUT_48] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9281,23 +9450,23 @@ fn aiur_fn_48( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_49: usize = 9; -const IN_49: usize = 9; -const OUT_49: usize = 9; -fn aiur_fn_49( - inp: [G; IN_49], +const INPUT_SIZE_51: usize = 9; +const IN_51: usize = 9; +const OUT_51: usize = 9; +fn aiur_fn_51( + inp: [G; IN_51], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_49], ExecError> { +) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9320,7 +9489,7 @@ fn aiur_fn_49( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9330,28 +9499,28 @@ fn aiur_fn_49( let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; - let __ret: [G; OUT_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_50: usize = 10; -const IN_50: usize = 10; -const OUT_50: usize = 1; -fn aiur_fn_50( - inp: [G; IN_50], +const INPUT_SIZE_52: usize = 10; +const IN_52: usize = 10; +const OUT_52: usize = 1; +fn aiur_fn_52( + inp: [G; IN_52], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_50], ExecError> { +) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9368,12 +9537,12 @@ fn aiur_fn_50( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_50] = [__v_12]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_12]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -9382,7 +9551,7 @@ fn aiur_fn_50( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9393,12 +9562,12 @@ fn aiur_fn_50( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_50] = [__v_29]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_29]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { @@ -9431,14 +9600,14 @@ fn aiur_fn_50( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_50] = [__v_39]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_39]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { @@ -9471,22 +9640,22 @@ fn aiur_fn_50( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_50] = [__v_39]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_39]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_50] = [__v_11]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_11]; + if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9496,15 +9665,15 @@ fn aiur_fn_50( }) } -const INPUT_SIZE_51: usize = 2; -const IN_51: usize = 2; -const OUT_51: usize = 1; -fn aiur_fn_51( - inp: [G; IN_51], +const INPUT_SIZE_53: usize = 2; +const IN_53: usize = 2; +const OUT_53: usize = 1; +fn aiur_fn_53( + inp: [G; IN_53], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_51], ExecError> { +) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9514,8 +9683,8 @@ fn aiur_fn_51( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_51] = [__v_1]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_1]; + if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -9538,12 +9707,12 @@ fn aiur_fn_51( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_24]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_24]; + if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9553,15 +9722,15 @@ fn aiur_fn_51( }) } -const INPUT_SIZE_52: usize = 2; -const IN_52: usize = 2; -const OUT_52: usize = 1; -fn aiur_fn_52( - inp: [G; IN_52], +const INPUT_SIZE_54: usize = 2; +const IN_54: usize = 2; +const OUT_54: usize = 1; +fn aiur_fn_54( + inp: [G; IN_54], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_52], ExecError> { +) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9571,8 +9740,8 @@ fn aiur_fn_52( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_52] = [__v_1]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__v_1]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -9586,12 +9755,12 @@ fn aiur_fn_52( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_52] = [__v_15]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__v_15]; + if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9601,15 +9770,15 @@ fn aiur_fn_52( }) } -const INPUT_SIZE_53: usize = 2; -const IN_53: usize = 2; -const OUT_53: usize = 1; -fn aiur_fn_53( - inp: [G; IN_53], +const INPUT_SIZE_55: usize = 2; +const IN_55: usize = 2; +const OUT_55: usize = 1; +fn aiur_fn_55( + inp: [G; IN_55], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_53], ExecError> { +) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9619,17 +9788,17 @@ fn aiur_fn_53( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_53] = [__v_1]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_55] = [__v_1]; + if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_53] = [__v_6]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_55] = [__v_6]; + if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9639,67 +9808,15 @@ fn aiur_fn_53( }) } -const INPUT_SIZE_54: usize = 2; -const IN_54: usize = 2; -const OUT_54: usize = 1; -fn aiur_fn_54( - inp: [G; IN_54], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_54], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - match __v_0.as_canonical_u64() { - 0u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_54] = [__v_4]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_54] = [__v_4]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_54] = [__v_4]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_54] = [__v_4]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_55: usize = 13; -const IN_55: usize = 13; -const OUT_55: usize = 1; -fn aiur_fn_55( - inp: [G; IN_55], +const INPUT_SIZE_56: usize = 13; +const IN_56: usize = 13; +const OUT_56: usize = 1; +fn aiur_fn_56( + inp: [G; IN_56], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_55], ExecError> { +) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9754,7 +9871,7 @@ fn aiur_fn_55( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; @@ -9764,23 +9881,23 @@ fn aiur_fn_55( let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_55] = [__v_54]; - if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_56] = [__v_54]; + if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_56: usize = 10; -const IN_56: usize = 10; -const OUT_56: usize = 1; -fn aiur_fn_56( - inp: [G; IN_56], +const INPUT_SIZE_57: usize = 10; +const IN_57: usize = 10; +const OUT_57: usize = 1; +fn aiur_fn_57( + inp: [G; IN_57], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_56], ExecError> { +) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9817,23 +9934,23 @@ fn aiur_fn_56( let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_56] = [__v_29]; - if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_57] = [__v_29]; + if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_57: usize = 2; -const IN_57: usize = 2; -const OUT_57: usize = 1; -fn aiur_fn_57( - inp: [G; IN_57], +const INPUT_SIZE_58: usize = 2; +const IN_58: usize = 2; +const OUT_58: usize = 1; +fn aiur_fn_58( + inp: [G; IN_58], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_57], ExecError> { +) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9851,17 +9968,17 @@ fn aiur_fn_57( let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_57] = [__v_1]; - if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_58] = [__v_1]; + if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_57] = [__v_14]; - if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_58] = [__v_14]; + if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -9871,15 +9988,15 @@ fn aiur_fn_57( }) } -const INPUT_SIZE_58: usize = 45; -const IN_58: usize = 45; -const OUT_58: usize = 1; -fn aiur_fn_58( - inp: [G; IN_58], +const INPUT_SIZE_59: usize = 45; +const IN_59: usize = 45; +const OUT_59: usize = 1; +fn aiur_fn_59( + inp: [G; IN_59], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_58], ExecError> { +) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9950,7 +10067,7 @@ fn aiur_fn_58( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9960,7 +10077,7 @@ fn aiur_fn_58( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; @@ -9977,23 +10094,23 @@ fn aiur_fn_58( let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_58] = [__v_83]; - if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_59] = [__v_83]; + if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_59: usize = 11; -const IN_59: usize = 11; -const OUT_59: usize = 1; -fn aiur_fn_59( - inp: [G; IN_59], +const INPUT_SIZE_60: usize = 11; +const IN_60: usize = 11; +const OUT_60: usize = 1; +fn aiur_fn_60( + inp: [G; IN_60], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_59], ExecError> { +) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10033,23 +10150,23 @@ fn aiur_fn_59( let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_59] = [__v_32]; - if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_60] = [__v_32]; + if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_60: usize = 11; -const IN_60: usize = 11; -const OUT_60: usize = 1; -fn aiur_fn_60( - inp: [G; IN_60], +const INPUT_SIZE_61: usize = 11; +const IN_61: usize = 11; +const OUT_61: usize = 1; +fn aiur_fn_61( + inp: [G; IN_61], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_60], ExecError> { +) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10087,25 +10204,25 @@ fn aiur_fn_60( let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_60] = [__v_31]; - if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_61] = [__v_31]; + if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_61: usize = 35; -const IN_61: usize = 35; -const OUT_61: usize = 1; -fn aiur_fn_61( - inp: [G; IN_61], +const INPUT_SIZE_62: usize = 35; +const IN_62: usize = 35; +const OUT_62: usize = 1; +fn aiur_fn_62( + inp: [G; IN_62], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_61], ExecError> { +) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10175,23 +10292,23 @@ fn aiur_fn_61( let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_61] = [__v_59]; - if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_62] = [__v_59]; + if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_62: usize = 2; -const IN_62: usize = 2; -const OUT_62: usize = 1; -fn aiur_fn_62( - inp: [G; IN_62], +const INPUT_SIZE_63: usize = 2; +const IN_63: usize = 2; +const OUT_63: usize = 1; +fn aiur_fn_63( + inp: [G; IN_63], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_62], ExecError> { +) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10234,17 +10351,17 @@ fn aiur_fn_62( let __v_37: G = __loaded[35]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_62] = [__v_1]; - if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_63] = [__v_1]; + if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_62] = [__v_39]; - if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_63] = [__v_39]; + if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10254,15 +10371,15 @@ fn aiur_fn_62( }) } -const INPUT_SIZE_63: usize = 28; -const IN_63: usize = 28; -const OUT_63: usize = 1; -fn aiur_fn_63( - inp: [G; IN_63], +const INPUT_SIZE_64: usize = 28; +const IN_64: usize = 28; +const OUT_64: usize = 1; +fn aiur_fn_64( + inp: [G; IN_64], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_63], ExecError> { +) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10313,7 +10430,7 @@ fn aiur_fn_63( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10323,7 +10440,7 @@ fn aiur_fn_63( 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_62] = { let __args: [G; IN_62] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; @@ -10336,23 +10453,23 @@ fn aiur_fn_63( let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_63] = [__v_61]; - if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_64] = [__v_61]; + if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_64: usize = 10; -const IN_64: usize = 10; -const OUT_64: usize = 1; -fn aiur_fn_64( - inp: [G; IN_64], +const INPUT_SIZE_65: usize = 10; +const IN_65: usize = 10; +const OUT_65: usize = 1; +fn aiur_fn_65( + inp: [G; IN_65], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_64], ExecError> { +) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10366,27 +10483,27 @@ fn aiur_fn_64( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_64] = [__v_11]; - if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_65] = [__v_11]; + if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_65: usize = 18; -const IN_65: usize = 18; -const OUT_65: usize = 1; -fn aiur_fn_65( - inp: [G; IN_65], +const INPUT_SIZE_66: usize = 18; +const IN_66: usize = 18; +const OUT_66: usize = 1; +fn aiur_fn_66( + inp: [G; IN_66], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_65], ExecError> { +) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10408,29 +10525,29 @@ fn aiur_fn_65( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_65] = [__v_20]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_66] = [__v_20]; + if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_66: usize = 46; -const IN_66: usize = 46; -const OUT_66: usize = 1; -fn aiur_fn_66( - inp: [G; IN_66], +const INPUT_SIZE_67: usize = 46; +const IN_67: usize = 46; +const OUT_67: usize = 1; +fn aiur_fn_67( + inp: [G; IN_67], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_66], ExecError> { +) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10482,31 +10599,31 @@ fn aiur_fn_66( 0u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = { 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_66] = [__v_49]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_67] = [__v_49]; + if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_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_66] = [__v_49]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_67] = [__v_49]; + if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; let __v_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_66] = [__v_49]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_67] = [__v_49]; + if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10516,15 +10633,15 @@ fn aiur_fn_66( }) } -const INPUT_SIZE_67: usize = 2; -const IN_67: usize = 2; -const OUT_67: usize = 1; -fn aiur_fn_67( - inp: [G; IN_67], +const INPUT_SIZE_68: usize = 2; +const IN_68: usize = 2; +const OUT_68: usize = 1; +fn aiur_fn_68( + inp: [G; IN_68], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_67], ExecError> { +) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10578,17 +10695,17 @@ fn aiur_fn_67( let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_67] = [__v_1]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_1]; + if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_50]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_50]; + if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10598,15 +10715,15 @@ fn aiur_fn_67( }) } -const INPUT_SIZE_68: usize = 46; -const IN_68: usize = 46; -const OUT_68: usize = 1; -fn aiur_fn_68( - inp: [G; IN_68], +const INPUT_SIZE_69: usize = 46; +const IN_69: usize = 46; +const OUT_69: usize = 1; +fn aiur_fn_69( + inp: [G; IN_69], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_68], ExecError> { +) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10656,59 +10773,59 @@ fn aiur_fn_68( let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_68] = [__v_46]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_46]; + if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -10718,37 +10835,6 @@ fn aiur_fn_68( }) } -const INPUT_SIZE_69: usize = 2; -const IN_69: usize = 2; -const OUT_69: usize = 1; -fn aiur_fn_69( - inp: [G; IN_69], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_69], 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_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __v_3: G = __r_arr[1]; - let __v_4: G = __r_arr[2]; - let __v_5: G = __r_arr[3]; - let __v_6: G = __r_arr[4]; - let __v_7: G = __r_arr[5]; - let __v_8: G = __r_arr[6]; - let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_69] = [__v_11]; - if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_70: usize = 2; const IN_70: usize = 2; const OUT_70: usize = 1; @@ -10761,7 +10847,7 @@ fn aiur_fn_70( 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_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10792,7 +10878,7 @@ fn aiur_fn_71( 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_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10801,7 +10887,7 @@ fn aiur_fn_71( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -10811,8 +10897,8 @@ fn aiur_fn_71( }) } -const INPUT_SIZE_72: usize = 49; -const IN_72: usize = 49; +const INPUT_SIZE_72: usize = 2; +const IN_72: usize = 2; const OUT_72: usize = 1; fn aiur_fn_72( inp: [G; IN_72], @@ -10820,6 +10906,37 @@ fn aiur_fn_72( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_72] = [__v_11]; + if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_73: usize = 49; +const IN_73: usize = 49; +const OUT_73: usize = 1; +fn aiur_fn_73( + inp: [G; IN_73], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10872,15 +10989,15 @@ fn aiur_fn_72( let __v_48: G = inp[48]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -10890,12 +11007,12 @@ fn aiur_fn_72( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -10908,12 +11025,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -10926,12 +11043,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { @@ -10944,12 +11061,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { @@ -10962,12 +11079,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -10980,12 +11097,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { @@ -10998,12 +11115,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { @@ -11016,12 +11133,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -11034,12 +11151,12 @@ fn aiur_fn_72( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_72] = [__v_62]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_62]; + if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11051,15 +11168,15 @@ fn aiur_fn_72( }) } -const INPUT_SIZE_73: usize = 1; -const IN_73: usize = 1; -const OUT_73: usize = 2; -fn aiur_fn_73( - inp: [G; IN_73], +const INPUT_SIZE_74: usize = 1; +const IN_74: usize = 1; +const OUT_74: usize = 2; +fn aiur_fn_74( + inp: [G; IN_74], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_73], ExecError> { +) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 }; @@ -11068,8 +11185,8 @@ fn aiur_fn_73( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_73] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_74] = [__v_2, __v_3]; + if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -11077,8 +11194,8 @@ fn aiur_fn_73( 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_73] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_74] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11088,15 +11205,15 @@ fn aiur_fn_73( }) } -const INPUT_SIZE_74: usize = 2; -const IN_74: usize = 2; -const OUT_74: usize = 9; -fn aiur_fn_74( - inp: [G; IN_74], +const INPUT_SIZE_75: usize = 2; +const IN_75: usize = 2; +const OUT_75: usize = 9; +fn aiur_fn_75( + inp: [G; IN_75], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_74], ExecError> { +) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11110,8 +11227,8 @@ fn aiur_fn_74( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_74] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_75] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; + if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11123,7 +11240,7 @@ fn aiur_fn_74( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -11133,8 +11250,8 @@ fn aiur_fn_74( let __v_13: G = __r_arr[6]; let __v_14: G = __r_arr[7]; let __v_15: G = __r_arr[8]; - let __ret: [G; OUT_74] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_75] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; + if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11146,15 +11263,15 @@ fn aiur_fn_74( }) } -const INPUT_SIZE_75: usize = 1; -const IN_75: usize = 1; -const OUT_75: usize = 9; -fn aiur_fn_75( - inp: [G; IN_75], +const INPUT_SIZE_76: usize = 1; +const IN_76: usize = 1; +const OUT_76: usize = 9; +fn aiur_fn_76( + inp: [G; IN_76], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_75], ExecError> { +) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -11199,8 +11316,8 @@ fn aiur_fn_75( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_75] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_76] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; + if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11212,7 +11329,7 @@ fn aiur_fn_75( if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) }); } - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; @@ -11222,8 +11339,8 @@ fn aiur_fn_75( let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; - let __ret: [G; OUT_75] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11235,15 +11352,15 @@ fn aiur_fn_75( }) } -const INPUT_SIZE_76: usize = 1; -const IN_76: usize = 1; -const OUT_76: usize = 10; -fn aiur_fn_76( - inp: [G; IN_76], +const INPUT_SIZE_77: usize = 1; +const IN_77: usize = 1; +const OUT_77: usize = 10; +fn aiur_fn_77( + inp: [G; IN_77], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_76], ExecError> { +) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -11285,14 +11402,14 @@ fn aiur_fn_76( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_76] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_77] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; + if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11308,8 +11425,8 @@ fn aiur_fn_76( if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) }); } - let __ret: [G; OUT_76] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_77] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11321,15 +11438,15 @@ fn aiur_fn_76( }) } -const INPUT_SIZE_77: usize = 1; -const IN_77: usize = 1; -const OUT_77: usize = 10; -fn aiur_fn_77( - inp: [G; IN_77], +const INPUT_SIZE_78: usize = 1; +const IN_78: usize = 1; +const OUT_78: usize = 10; +fn aiur_fn_78( + inp: [G; IN_78], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_77], ExecError> { +) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 }; @@ -11371,14 +11488,14 @@ fn aiur_fn_77( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_77] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_78] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; + if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11388,8 +11505,8 @@ fn aiur_fn_77( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __ret: [G; OUT_77] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_78] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11401,15 +11518,15 @@ fn aiur_fn_77( }) } -const INPUT_SIZE_78: usize = 9; -const IN_78: usize = 9; -const OUT_78: usize = 2; -fn aiur_fn_78( - inp: [G; IN_78], +const INPUT_SIZE_79: usize = 9; +const IN_79: usize = 9; +const OUT_79: usize = 2; +fn aiur_fn_79( + inp: [G; IN_79], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_78], ExecError> { +) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11427,12 +11544,12 @@ fn aiur_fn_78( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_78] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_79] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -11451,13 +11568,13 @@ fn aiur_fn_78( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_78] = [__v_30, __v_28]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_79] = [__v_30, __v_28]; + if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11467,15 +11584,15 @@ fn aiur_fn_78( }) } -const INPUT_SIZE_79: usize = 10; -const IN_79: usize = 10; -const OUT_79: usize = 2; -fn aiur_fn_79( - inp: [G; IN_79], +const INPUT_SIZE_80: usize = 10; +const IN_80: usize = 10; +const OUT_80: usize = 2; +fn aiur_fn_80( + inp: [G; IN_80], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_79], ExecError> { +) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11491,12 +11608,12 @@ fn aiur_fn_79( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_79] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_80] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); @@ -11511,82 +11628,22 @@ fn aiur_fn_79( let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __ret: [G; OUT_79] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_80: usize = 9; -const IN_80: usize = 9; -const OUT_80: usize = 2; -fn aiur_fn_80( - inp: [G; IN_80], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_80], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - match __v_9.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_80] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __v_13: G = __r_arr[1]; - let __v_14: G = __r_arr[2]; - let __v_15: G = __r_arr[3]; - let __v_16: G = __r_arr[4]; - let __v_17: G = __r_arr[5]; - let __v_18: G = __r_arr[6]; - let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = __r_arr[1]; - let __v_22: G = G::from_u64(8); - let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_80] = [__v_24, __v_21]; + let __ret: [G; OUT_80] = [__v_24, __v_25]; if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_81: usize = 9; -const IN_81: usize = 9; +const INPUT_SIZE_81: usize = 1; +const IN_81: usize = 1; const OUT_81: usize = 2; fn aiur_fn_81( inp: [G; IN_81], @@ -11596,50 +11653,50 @@ fn aiur_fn_81( ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - match __v_9.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_81] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __v_13: G = __r_arr[1]; - let __v_14: G = __r_arr[2]; - let __v_15: G = __r_arr[3]; - let __v_16: G = __r_arr[4]; - let __v_17: G = __r_arr[5]; - let __v_18: G = __r_arr[6]; - let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = __r_arr[1]; - let __v_22: G = G::from_u64(9); - let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __v_4: G = G::from_u64(4); + let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; + let __v_6: G = G::from_u64(1); + if (__v_5 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid lambda mode".to_string()) }); + } + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_81] = [__v_7, __v_3]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_81] = [__v_7, __v_3]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __v_7: G = G::from_u64(2); + let __ret: [G; OUT_81] = [__v_7, __v_3]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __ret: [G; OUT_81] = [__v_7, __v_3]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } }, _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) @@ -11647,7 +11704,7 @@ fn aiur_fn_81( const INPUT_SIZE_82: usize = 1; const IN_82: usize = 1; -const OUT_82: usize = 2; +const OUT_82: usize = 3; fn aiur_fn_82( inp: [G; IN_82], record: &mut QueryRecord, @@ -11656,172 +11713,79 @@ fn aiur_fn_82( ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __v_3: G = __r_arr[2]; - let __v_4: G = __r_arr[3]; - let __v_5: G = __r_arr[4]; - let __v_6: G = __r_arr[5]; - let __v_7: G = __r_arr[6]; - let __v_8: G = __r_arr[7]; - let __v_9: G = __r_arr[8]; - let __v_10: G = __r_arr[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __v_11: G = G::from_u64(0); - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __v_11: G = G::from_u64(1); - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __v_13: G = __r_arr[2]; - let __v_14: G = __r_arr[3]; - let __v_15: G = __r_arr[4]; - let __v_16: G = __r_arr[5]; - let __v_17: G = __r_arr[6]; - let __v_18: G = __r_arr[7]; - let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = __r_arr[1]; - let __v_22: G = G::from_u64(2); - let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __v_13: G = __r_arr[2]; - let __v_14: G = __r_arr[3]; - let __v_15: G = __r_arr[4]; - let __v_16: G = __r_arr[5]; - let __v_17: G = __r_arr[6]; - let __v_18: G = __r_arr[7]; - let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = __r_arr[1]; - let __v_22: G = G::from_u64(3); - let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 4u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __v_13: G = __r_arr[2]; - let __v_14: G = __r_arr[3]; - let __v_15: G = __r_arr[4]; - let __v_16: G = __r_arr[5]; - let __v_17: G = __r_arr[6]; - let __v_18: G = __r_arr[7]; - let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = __r_arr[1]; - let __v_22: G = G::from_u64(4); - let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 5u64 => { - let __v_11: G = G::from_u64(5); - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 6u64 => { - let __v_11: G = G::from_u64(6); - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 7u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = G::from_u64(0); - if (__v_13 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); - } - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_82] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 8u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = G::from_u64(0); - if (__v_11 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); + let __v_4: G = G::from_u64(8); + let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; + let __v_6: G = G::from_u64(1); + if (__v_5 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid forall mode".to_string()) }); } - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_82] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 9u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = G::from_u64(0); - if (__v_11 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 7u64 => { + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; + if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, } - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_82] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 10u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_82] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 11u64 => { - let __v_11: G = G::from_u64(11); - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); @@ -11849,33 +11813,472 @@ fn aiur_fn_83( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = __r_arr[1]; - let __v_15: G = G::from_u64(10); - let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_83] = [__v_17, __v_14]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + let __v_23: G = __loaded[11]; + let __v_24: G = __loaded[12]; + let __v_25: G = __loaded[13]; + let __v_26: G = __loaded[14]; + let __v_27: G = __loaded[15]; + let __v_28: G = __loaded[16]; + let __v_29: G = __loaded[17]; + match __v_12.as_canonical_u64() { + 8u64 => { + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(1); + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) }); + } + let __ret: [G; OUT_83] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_83] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + let __v_24: G = G::from_u64(8); + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_83] = [__v_26, __v_23]; + if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_84: usize = 17; -const IN_84: usize = 17; -const OUT_84: usize = 9; +const INPUT_SIZE_84: usize = 9; +const IN_84: usize = 9; +const OUT_84: usize = 2; fn aiur_fn_84( inp: [G; IN_84], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + let __v_23: G = __loaded[11]; + let __v_24: G = __loaded[12]; + let __v_25: G = __loaded[13]; + let __v_26: G = __loaded[14]; + let __v_27: G = __loaded[15]; + let __v_28: G = __loaded[16]; + let __v_29: G = __loaded[17]; + match __v_12.as_canonical_u64() { + 9u64 => { + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(1); + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) }); + } + let __ret: [G; OUT_84] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_84] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = __r_arr[3]; + let __v_19: G = __r_arr[4]; + let __v_20: G = __r_arr[5]; + let __v_21: G = __r_arr[6]; + let __v_22: G = __r_arr[7]; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_84] = [__v_27, __v_24]; + if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_85: usize = 1; +const IN_85: usize = 1; +const OUT_85: usize = 2; +fn aiur_fn_85( + inp: [G; IN_85], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_85], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(4); + let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 5u64 => { + let __v_11: G = G::from_u64(5); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __v_11: G = G::from_u64(6); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + if (__v_13 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); + } + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __v_18: G = __loaded[3]; + let __v_19: G = __loaded[4]; + let __v_20: G = __loaded[5]; + let __v_21: G = __loaded[6]; + let __v_22: G = __loaded[7]; + let __v_23: G = __loaded[8]; + let __v_24: G = __loaded[9]; + let __v_25: G = __loaded[10]; + let __v_26: G = __loaded[11]; + let __v_27: G = __loaded[12]; + let __v_28: G = __loaded[13]; + let __v_29: G = __loaded[14]; + let __v_30: G = __loaded[15]; + let __v_31: G = __loaded[16]; + let __v_32: G = __loaded[17]; + match __v_15.as_canonical_u64() { + 7u64 => { + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(1); + if (__v_33 != __v_34) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) }); + } + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __ret: [G; OUT_85] = [__v_35, __v_36]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __ret: [G; OUT_85] = [__v_33, __v_34]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 8u64 => { + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); + } + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_85] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 9u64 => { + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); + } + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_85] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 10u64 => { + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_85] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 11u64 => { + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_13, __v_10]; + if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_86: usize = 9; +const IN_86: usize = 9; +const OUT_86: usize = 2; +fn aiur_fn_86( + inp: [G; IN_86], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_86], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = (__v_17 + __v_26); + let __v_34: G = G::from_u64(1); + if (__v_33 != __v_34) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("invalid let nonDep flag".to_string()) }); + } + let __v_35: G = G::from_u64(10); + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27, __v_29, __v_31, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_86] = [__v_37, __v_32]; + if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_87: usize = 17; +const IN_87: usize = 17; +const OUT_87: usize = 9; +fn aiur_fn_87( + inp: [G; IN_87], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11898,8 +12301,8 @@ fn aiur_fn_84( let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11912,7 +12315,7 @@ fn aiur_fn_84( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -11925,8 +12328,8 @@ fn aiur_fn_84( let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_84] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; + if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11936,18 +12339,18 @@ fn aiur_fn_84( }) } -const INPUT_SIZE_85: usize = 1; -const IN_85: usize = 1; -const OUT_85: usize = 10; -fn aiur_fn_85( - inp: [G; IN_85], +const INPUT_SIZE_88: usize = 1; +const IN_88: usize = 1; +const OUT_88: usize = 10; +fn aiur_fn_88( + inp: [G; IN_88], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_85], ExecError> { +) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11966,12 +12369,12 @@ fn aiur_fn_85( 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_85] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11982,7 +12385,7 @@ fn aiur_fn_85( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -11992,8 +12395,8 @@ fn aiur_fn_85( let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; - let __ret: [G; OUT_85] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12002,7 +12405,7 @@ fn aiur_fn_85( } }, 1u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12013,7 +12416,7 @@ fn aiur_fn_85( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12028,12 +12431,12 @@ fn aiur_fn_85( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12044,7 +12447,7 @@ fn aiur_fn_85( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12059,14 +12462,14 @@ fn aiur_fn_85( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); - let __ret: [G; OUT_85] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12076,15 +12479,15 @@ fn aiur_fn_85( }) } -const INPUT_SIZE_86: usize = 1; -const IN_86: usize = 1; -const OUT_86: usize = 2; -fn aiur_fn_86( - inp: [G; IN_86], +const INPUT_SIZE_89: usize = 1; +const IN_89: usize = 1; +const OUT_89: usize = 2; +fn aiur_fn_89( + inp: [G; IN_89], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_86], ExecError> { +) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -12280,8 +12683,8 @@ fn aiur_fn_86( match __v_94.as_canonical_u64() { 0u64 => { let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_86] = [__v_97, __v_96]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_89] = [__v_97, __v_96]; + if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12446,15 +12849,15 @@ fn aiur_fn_86( }) } -const INPUT_SIZE_87: usize = 9; -const IN_87: usize = 9; -const OUT_87: usize = 2; -fn aiur_fn_87( - inp: [G; IN_87], +const INPUT_SIZE_90: usize = 9; +const IN_90: usize = 9; +const OUT_90: usize = 2; +fn aiur_fn_90( + inp: [G; IN_90], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_87], ExecError> { +) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12472,12 +12875,12 @@ fn aiur_fn_87( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_87] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_90] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -12489,13 +12892,13 @@ fn aiur_fn_87( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_87] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_90] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12505,15 +12908,15 @@ fn aiur_fn_87( }) } -const INPUT_SIZE_88: usize = 9; -const IN_88: usize = 9; -const OUT_88: usize = 2; -fn aiur_fn_88( - inp: [G; IN_88], +const INPUT_SIZE_91: usize = 9; +const IN_91: usize = 9; +const OUT_91: usize = 2; +fn aiur_fn_91( + inp: [G; IN_91], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_88], ExecError> { +) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12531,12 +12934,12 @@ fn aiur_fn_88( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_91] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12556,14 +12959,14 @@ fn aiur_fn_88( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_32, __v_29]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_91] = [__v_32, __v_29]; + if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12573,15 +12976,15 @@ fn aiur_fn_88( }) } -const INPUT_SIZE_89: usize = 9; -const IN_89: usize = 9; -const OUT_89: usize = 2; -fn aiur_fn_89( - inp: [G; IN_89], +const INPUT_SIZE_92: usize = 9; +const IN_92: usize = 9; +const OUT_92: usize = 2; +fn aiur_fn_92( + inp: [G; IN_92], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_89], ExecError> { +) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12599,12 +13002,12 @@ fn aiur_fn_89( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_89] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_92] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -12616,13 +13019,13 @@ fn aiur_fn_89( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_89] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_92] = [__v_23, __v_21]; + if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12632,18 +13035,18 @@ fn aiur_fn_89( }) } -const INPUT_SIZE_90: usize = 1; -const IN_90: usize = 1; -const OUT_90: usize = 2; -fn aiur_fn_90( - inp: [G; IN_90], +const INPUT_SIZE_93: usize = 1; +const IN_93: usize = 1; +const OUT_93: usize = 2; +fn aiur_fn_93( + inp: [G; IN_93], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_90], ExecError> { +) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12653,27 +13056,27 @@ fn aiur_fn_90( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_90] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_91: usize = 1; -const IN_91: usize = 1; -const OUT_91: usize = 2; -fn aiur_fn_91( - inp: [G; IN_91], +const INPUT_SIZE_94: usize = 1; +const IN_94: usize = 1; +const OUT_94: usize = 2; +fn aiur_fn_94( + inp: [G; IN_94], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_91], ExecError> { +) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12683,27 +13086,27 @@ fn aiur_fn_91( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_91] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_94] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_92: usize = 1; -const IN_92: usize = 1; -const OUT_92: usize = 2; -fn aiur_fn_92( - inp: [G; IN_92], +const INPUT_SIZE_95: usize = 1; +const IN_95: usize = 1; +const OUT_95: usize = 2; +fn aiur_fn_95( + inp: [G; IN_95], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_92], ExecError> { +) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12713,88 +13116,88 @@ fn aiur_fn_92( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_92] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_95] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 1; -const IN_93: usize = 1; -const OUT_93: usize = 2; -fn aiur_fn_93( - inp: [G; IN_93], +const INPUT_SIZE_96: usize = 1; +const IN_96: usize = 1; +const OUT_96: usize = 2; +fn aiur_fn_96( + inp: [G; IN_96], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_93], ExecError> { +) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_93] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_1, __v_2]; + if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12804,24 +13207,24 @@ fn aiur_fn_93( }) } -const INPUT_SIZE_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 13; -fn aiur_fn_94( - inp: [G; IN_94], +const INPUT_SIZE_97: usize = 1; +const IN_97: usize = 1; +const OUT_97: usize = 13; +fn aiur_fn_97( + inp: [G; IN_97], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_94], ExecError> { +) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -12831,30 +13234,30 @@ fn aiur_fn_94( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_94] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; - if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_97] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; + if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_95: usize = 1; -const IN_95: usize = 1; -const OUT_95: usize = 10; -fn aiur_fn_95( - inp: [G; IN_95], +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 10; +fn aiur_fn_98( + inp: [G; IN_98], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_95], ExecError> { +) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12864,24 +13267,24 @@ fn aiur_fn_95( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_95] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_98] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_96: usize = 9; -const IN_96: usize = 9; -const OUT_96: usize = 2; -fn aiur_fn_96( - inp: [G; IN_96], +const INPUT_SIZE_99: usize = 9; +const IN_99: usize = 9; +const OUT_99: usize = 2; +fn aiur_fn_99( + inp: [G; IN_99], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_96], ExecError> { +) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12899,12 +13302,12 @@ fn aiur_fn_96( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_96] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_99] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12914,7 +13317,7 @@ fn aiur_fn_96( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -12926,13 +13329,13 @@ fn aiur_fn_96( let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_96] = [__v_32, __v_30]; - if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_99] = [__v_32, __v_30]; + if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -12942,18 +13345,18 @@ fn aiur_fn_96( }) } -const INPUT_SIZE_97: usize = 1; -const IN_97: usize = 1; -const OUT_97: usize = 45; -fn aiur_fn_97( - inp: [G; IN_97], +const INPUT_SIZE_100: usize = 1; +const IN_100: usize = 1; +const OUT_100: usize = 45; +fn aiur_fn_100( + inp: [G; IN_100], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_97], ExecError> { +) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -12965,7 +13368,7 @@ fn aiur_fn_97( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12975,7 +13378,7 @@ fn aiur_fn_97( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12985,7 +13388,7 @@ fn aiur_fn_97( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -12995,7 +13398,7 @@ fn aiur_fn_97( 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_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -13005,7 +13408,7 @@ fn aiur_fn_97( 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_75] = { let __args: [G; IN_75] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -13015,10 +13418,10 @@ fn aiur_fn_97( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -13028,24 +13431,24 @@ fn aiur_fn_97( let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; - let __ret: [G; OUT_97] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; - if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; + if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_98: usize = 1; -const IN_98: usize = 1; -const OUT_98: usize = 0; -fn aiur_fn_98( - inp: [G; IN_98], +const INPUT_SIZE_101: usize = 1; +const IN_101: usize = 1; +const OUT_101: usize = 0; +fn aiur_fn_101( + inp: [G; IN_101], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_98], ExecError> { +) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(2); @@ -13054,28 +13457,28 @@ fn aiur_fn_98( if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } - let __ret: [G; OUT_98] = []; - if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_101] = []; + if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_99: usize = 1; -const IN_99: usize = 1; -const OUT_99: usize = 11; -fn aiur_fn_99( - inp: [G; IN_99], +const INPUT_SIZE_102: usize = 1; +const IN_102: usize = 1; +const OUT_102: usize = 11; +fn aiur_fn_102( + inp: [G; IN_102], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_99], ExecError> { +) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13085,49 +13488,49 @@ fn aiur_fn_99( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_99] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; + if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_100: usize = 1; -const IN_100: usize = 1; -const OUT_100: usize = 1; -fn aiur_fn_100( - inp: [G; IN_100], +const INPUT_SIZE_103: usize = 1; +const IN_103: usize = 1; +const OUT_103: usize = 1; +fn aiur_fn_103( + inp: [G; IN_103], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_100], ExecError> { +) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_100] = [__v_1]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_1]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_100] = [__v_1]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_1]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_100] = [__v_1]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_1]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); - let __ret: [G; OUT_100] = [__v_1]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_1]; + if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13137,23 +13540,23 @@ fn aiur_fn_100( }) } -const INPUT_SIZE_101: usize = 1; -const IN_101: usize = 1; -const OUT_101: usize = 11; -fn aiur_fn_101( - inp: [G; IN_101], +const INPUT_SIZE_104: usize = 1; +const IN_104: usize = 1; +const OUT_104: usize = 11; +fn aiur_fn_104( + inp: [G; IN_104], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_101], ExecError> { +) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -13163,31 +13566,31 @@ fn aiur_fn_101( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; - if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; + if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_102: usize = 1; -const IN_102: usize = 1; -const OUT_102: usize = 35; -fn aiur_fn_102( - inp: [G; IN_102], +const INPUT_SIZE_105: usize = 1; +const IN_105: usize = 1; +const OUT_105: usize = 35; +fn aiur_fn_105( + inp: [G; IN_105], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_102], ExecError> { +) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13197,7 +13600,7 @@ fn aiur_fn_102( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13207,7 +13610,7 @@ fn aiur_fn_102( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -13217,7 +13620,7 @@ fn aiur_fn_102( let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; @@ -13227,24 +13630,24 @@ fn aiur_fn_102( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_105] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; + if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_103: usize = 9; -const IN_103: usize = 9; -const OUT_103: usize = 2; -fn aiur_fn_103( - inp: [G; IN_103], +const INPUT_SIZE_106: usize = 9; +const IN_106: usize = 9; +const OUT_106: usize = 2; +fn aiur_fn_106( + inp: [G; IN_106], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_103], ExecError> { +) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13262,12 +13665,12 @@ fn aiur_fn_103( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_103] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_106] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13312,13 +13715,13 @@ fn aiur_fn_103( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_103] = [__v_56, __v_54]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_106] = [__v_56, __v_54]; + if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13328,18 +13731,18 @@ fn aiur_fn_103( }) } -const INPUT_SIZE_104: usize = 1; -const IN_104: usize = 1; -const OUT_104: usize = 28; -fn aiur_fn_104( - inp: [G; IN_104], +const INPUT_SIZE_107: usize = 1; +const IN_107: usize = 1; +const OUT_107: usize = 28; +fn aiur_fn_107( + inp: [G; IN_107], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_104], ExecError> { +) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -13351,7 +13754,7 @@ fn aiur_fn_104( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13361,7 +13764,7 @@ fn aiur_fn_104( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -13371,7 +13774,7 @@ fn aiur_fn_104( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -13381,10 +13784,10 @@ fn aiur_fn_104( 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_82] = { let __args: [G; IN_82] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -13394,27 +13797,27 @@ fn aiur_fn_104( let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __ret: [G; OUT_104] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; - if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; + if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_105: usize = 1; -const IN_105: usize = 1; -const OUT_105: usize = 10; -fn aiur_fn_105( - inp: [G; IN_105], +const INPUT_SIZE_108: usize = 1; +const IN_108: usize = 1; +const OUT_108: usize = 10; +fn aiur_fn_108( + inp: [G; IN_108], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_105], ExecError> { +) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13424,27 +13827,27 @@ fn aiur_fn_105( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 18; -fn aiur_fn_106( - inp: [G; IN_106], +const INPUT_SIZE_109: usize = 1; +const IN_109: usize = 1; +const OUT_109: usize = 18; +fn aiur_fn_109( + inp: [G; IN_109], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_106], ExecError> { +) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13454,7 +13857,7 @@ fn aiur_fn_106( 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_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13464,32 +13867,32 @@ fn aiur_fn_106( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_106] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; + if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 46; -fn aiur_fn_107( - inp: [G; IN_107], +const INPUT_SIZE_110: usize = 1; +const IN_110: usize = 1; +const OUT_110: usize = 46; +fn aiur_fn_110( + inp: [G; IN_110], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_107], ExecError> { +) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13505,12 +13908,12 @@ fn aiur_fn_107( let __v_15: G = __r_arr[12]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_107] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13541,12 +13944,12 @@ fn aiur_fn_107( let __v_30: G = __r_arr[27]; let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); - let __ret: [G; OUT_107] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13593,8 +13996,8 @@ fn aiur_fn_107( let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); - let __ret: [G; OUT_107] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13604,15 +14007,15 @@ fn aiur_fn_107( }) } -const INPUT_SIZE_108: usize = 9; -const IN_108: usize = 9; -const OUT_108: usize = 2; -fn aiur_fn_108( - inp: [G; IN_108], +const INPUT_SIZE_111: usize = 9; +const IN_111: usize = 9; +const OUT_111: usize = 2; +fn aiur_fn_111( + inp: [G; IN_111], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_108], ExecError> { +) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13630,12 +14033,12 @@ fn aiur_fn_108( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_108] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13691,13 +14094,13 @@ fn aiur_fn_108( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_108] = [__v_67, __v_65]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_67, __v_65]; + if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13707,21 +14110,21 @@ fn aiur_fn_108( }) } -const INPUT_SIZE_109: usize = 2; -const IN_109: usize = 2; -const OUT_109: usize = 46; -fn aiur_fn_109( - inp: [G; IN_109], +const INPUT_SIZE_112: usize = 2; +const IN_112: usize = 2; +const OUT_112: usize = 46; +fn aiur_fn_112( + inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_109], ExecError> { +) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13737,12 +14140,12 @@ fn aiur_fn_109( let __v_14: G = __r_arr[12]; let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13789,12 +14192,12 @@ fn aiur_fn_109( let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); - let __ret: [G; OUT_109] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13808,12 +14211,12 @@ fn aiur_fn_109( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13827,12 +14230,12 @@ fn aiur_fn_109( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13853,12 +14256,12 @@ fn aiur_fn_109( let __v_19: G = __r_arr[17]; let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13871,12 +14274,12 @@ fn aiur_fn_109( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13889,12 +14292,12 @@ fn aiur_fn_109( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13907,8 +14310,8 @@ fn aiur_fn_109( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -13918,15 +14321,15 @@ fn aiur_fn_109( }) } -const INPUT_SIZE_110: usize = 10; -const IN_110: usize = 10; -const OUT_110: usize = 46; -fn aiur_fn_110( - inp: [G; IN_110], +const INPUT_SIZE_113: usize = 10; +const IN_113: usize = 10; +const OUT_113: usize = 46; +fn aiur_fn_113( + inp: [G; IN_113], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_110], ExecError> { +) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13940,13 +14343,13 @@ fn aiur_fn_110( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_110] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 13u64 => { @@ -13960,7 +14363,7 @@ fn aiur_fn_110( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -14007,8 +14410,8 @@ fn aiur_fn_110( let __v_60: G = __r_arr[43]; let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; - let __ret: [G; OUT_110] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14018,18 +14421,18 @@ fn aiur_fn_110( }) } -const INPUT_SIZE_111: usize = 1; -const IN_111: usize = 1; -const OUT_111: usize = 49; -fn aiur_fn_111( - inp: [G; IN_111], +const INPUT_SIZE_114: usize = 1; +const IN_114: usize = 1; +const OUT_114: usize = 49; +fn aiur_fn_114( + inp: [G; IN_114], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_111], ExecError> { +) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -14042,7 +14445,7 @@ fn aiur_fn_111( let __v_10: G = __r_arr[9]; let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); @@ -14060,7 +14463,7 @@ fn aiur_fn_111( if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -14160,7 +14563,7 @@ fn aiur_fn_111( let __v_54: G = __mc_out___mc_0[43]; let __v_55: G = __mc_out___mc_0[44]; let __v_56: G = __mc_out___mc_0[45]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -14170,10 +14573,10 @@ fn aiur_fn_111( 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_87] = { let __args: [G; IN_87] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -14183,10 +14586,10 @@ fn aiur_fn_111( let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = __r_arr[2]; @@ -14196,24 +14599,24 @@ fn aiur_fn_111( let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __ret: [G; OUT_111] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; + if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_112: usize = 1; -const IN_112: usize = 1; -const OUT_112: usize = 2; -fn aiur_fn_112( - inp: [G; IN_112], +const INPUT_SIZE_115: usize = 1; +const IN_115: usize = 1; +const OUT_115: usize = 2; +fn aiur_fn_115( + inp: [G; IN_115], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_112], ExecError> { +) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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 }; @@ -14223,36 +14626,36 @@ fn aiur_fn_112( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_112] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_115] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { 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_112] = [__v_0, __v_7]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_115] = [__v_0, __v_7]; + if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_113: usize = 1; -const IN_113: usize = 1; -const OUT_113: usize = 1; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_116: usize = 1; +const IN_116: usize = 1; +const OUT_116: usize = 1; +fn aiur_fn_116( + inp: [G; IN_116], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; @@ -14281,8 +14684,8 @@ fn aiur_fn_113( let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_23]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_23]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14308,17 +14711,17 @@ fn aiur_fn_113( 0u64 => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_29]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_29]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_30]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_30]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14330,15 +14733,15 @@ fn aiur_fn_113( }) } -const INPUT_SIZE_114: usize = 3; -const IN_114: usize = 3; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_117: usize = 3; +const IN_117: usize = 3; +const OUT_117: usize = 1; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14358,15 +14761,15 @@ fn aiur_fn_114( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_114] = [__v_1]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_1]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_114] = [__v_13]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_13]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14387,15 +14790,15 @@ fn aiur_fn_114( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_114] = [__v_0]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_0]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_114] = [__v_23]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_23]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14430,11 +14833,11 @@ fn aiur_fn_114( let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_114] = [__v_51]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_51]; + if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14449,36 +14852,36 @@ fn aiur_fn_114( }) } -const INPUT_SIZE_115: usize = 2; -const IN_115: usize = 2; -const OUT_115: usize = 1; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_118: usize = 2; +const IN_118: usize = 2; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_115] = [__v_3]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_3]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_116: usize = 16; -const IN_116: usize = 16; -const OUT_116: usize = 9; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_119: usize = 16; +const IN_119: usize = 16; +const OUT_119: usize = 9; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14548,21 +14951,21 @@ fn aiur_fn_116( let __v_50: G = __b2_sub.0; let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_116] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_117: usize = 3; -const IN_117: usize = 3; -const OUT_117: usize = 2; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_120: usize = 3; +const IN_120: usize = 3; +const OUT_120: usize = 2; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14596,20 +14999,20 @@ fn aiur_fn_117( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_25, __v_2]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_25, __v_2]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_26, __v_2]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_26, __v_2]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14617,8 +15020,8 @@ fn aiur_fn_117( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_117] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14645,8 +15048,8 @@ fn aiur_fn_117( match __v_2.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_117] = [__v_0, __v_23]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_0, __v_23]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14658,7 +15061,7 @@ fn aiur_fn_117( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -14671,19 +15074,19 @@ fn aiur_fn_117( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_46, __v_44]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_46, __v_44]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14700,7 +15103,7 @@ fn aiur_fn_117( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14711,13 +15114,13 @@ fn aiur_fn_117( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_52, __v_50]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_52, __v_50]; + if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14732,15 +15135,15 @@ fn aiur_fn_117( }) } -const INPUT_SIZE_118: usize = 1; -const IN_118: usize = 1; -const OUT_118: usize = 1; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_121: usize = 1; +const IN_121: usize = 1; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -14759,8 +15162,8 @@ fn aiur_fn_118( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_13]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14769,11 +15172,11 @@ fn aiur_fn_118( if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_13]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14783,15 +15186,15 @@ fn aiur_fn_118( }) } -const INPUT_SIZE_119: usize = 1; -const IN_119: usize = 1; -const OUT_119: usize = 1; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_122: usize = 1; +const IN_122: usize = 1; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_122], 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 }; @@ -14810,12 +15213,12 @@ fn aiur_fn_119( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_13]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_13]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -14837,8 +15240,8 @@ fn aiur_fn_119( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_25]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_25]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14847,8 +15250,8 @@ fn aiur_fn_119( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_27]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_27]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14859,8 +15262,8 @@ fn aiur_fn_119( _ => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_23]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_23]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -14872,20 +15275,20 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 2; -const IN_120: usize = 2; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_123: usize = 2; +const IN_123: usize = 2; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -14893,15 +15296,15 @@ fn aiur_fn_120( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_7]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_7]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_120] = [__v_5]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_5]; + if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14911,19 +15314,19 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 2; -const IN_121: usize = 2; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_124: usize = 2; +const IN_124: usize = 2; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -14939,29 +15342,29 @@ fn aiur_fn_121( match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_121] = [__v_13]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_13]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_121] = [__v_13]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_13]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_122: usize = 1; -const IN_122: usize = 1; -const OUT_122: usize = 1; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_125: usize = 1; +const IN_125: usize = 1; +const OUT_125: usize = 1; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -14977,23 +15380,23 @@ fn aiur_fn_122( let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_122] = [__v_14]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_14]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_123: usize = 2; -const IN_123: usize = 2; -const OUT_123: usize = 2; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_126: usize = 2; +const IN_126: usize = 2; +const OUT_126: usize = 2; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15001,8 +15404,8 @@ fn aiur_fn_123( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_123] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15010,11 +15413,11 @@ fn aiur_fn_123( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_123] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15024,40 +15427,40 @@ fn aiur_fn_123( }) } -const INPUT_SIZE_124: usize = 1; -const IN_124: usize = 1; -const OUT_124: usize = 3; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_127: usize = 1; +const IN_127: usize = 1; +const OUT_127: usize = 3; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_124] = [__v_2, __v_5, __v_6]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_2, __v_5, __v_6]; + if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_125: usize = 16; -const IN_125: usize = 16; -const OUT_125: usize = 16; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_128: usize = 16; +const IN_128: usize = 16; +const OUT_128: usize = 16; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15188,7 +15591,7 @@ fn aiur_fn_125( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -15211,7 +15614,7 @@ fn aiur_fn_125( if (__v_16 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -15234,7 +15637,7 @@ fn aiur_fn_125( if (__v_141 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; @@ -15257,7 +15660,7 @@ fn aiur_fn_125( if (__v_160 != __v_185) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; @@ -15280,7 +15683,7 @@ fn aiur_fn_125( if (__v_179 != __v_204) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -15303,7 +15706,7 @@ fn aiur_fn_125( if (__v_198 != __v_223) { return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; @@ -15326,7 +15729,7 @@ fn aiur_fn_125( if (__v_217 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; @@ -15349,7 +15752,7 @@ fn aiur_fn_125( if (__v_236 != __v_261) { return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; @@ -15372,7 +15775,7 @@ fn aiur_fn_125( if (__v_255 != __v_280) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; @@ -15395,7 +15798,7 @@ fn aiur_fn_125( if (__v_274 != __v_299) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; @@ -15418,7 +15821,7 @@ fn aiur_fn_125( if (__v_293 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; @@ -15441,7 +15844,7 @@ fn aiur_fn_125( if (__v_312 != __v_337) { return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; @@ -15464,7 +15867,7 @@ fn aiur_fn_125( if (__v_331 != __v_356) { return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; @@ -15487,7 +15890,7 @@ fn aiur_fn_125( if (__v_350 != __v_375) { return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; @@ -15510,7 +15913,7 @@ fn aiur_fn_125( if (__v_369 != __v_394) { return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; @@ -15532,21 +15935,21 @@ fn aiur_fn_125( if (__v_388 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) }); } - let __ret: [G; OUT_125] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_126: usize = 2; -const IN_126: usize = 2; -const OUT_126: usize = 1; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_129: usize = 2; +const IN_129: usize = 2; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15554,23 +15957,23 @@ fn aiur_fn_126( let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_126] = [__v_6]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_6]; + if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_127: usize = 4; -const IN_127: usize = 4; -const OUT_127: usize = 1; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_130: usize = 4; +const IN_130: usize = 4; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15589,8 +15992,8 @@ fn aiur_fn_127( let __v_13: G = __loaded[9]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_127] = [__v_2]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_2]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -15605,18 +16008,18 @@ fn aiur_fn_127( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_127] = [__v_30]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_30]; + if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15626,15 +16029,15 @@ fn aiur_fn_127( }) } -const INPUT_SIZE_128: usize = 18; -const IN_128: usize = 18; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_131: usize = 18; +const IN_131: usize = 18; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15671,15 +16074,15 @@ fn aiur_fn_128( let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_128] = [__v_17]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_17]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_29]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_29]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15688,7 +16091,7 @@ fn aiur_fn_128( } }, 0u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -15732,12 +16135,12 @@ fn aiur_fn_128( let __v_66: G = __r_arr[6]; let __v_67: G = __r_arr[7]; let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_70]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_70]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15747,22 +16150,22 @@ fn aiur_fn_128( }) } -const INPUT_SIZE_129: usize = 2; -const IN_129: usize = 2; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_132: usize = 2; +const IN_132: usize = 2; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_129] = [__v_0]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_0]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15778,28 +16181,28 @@ fn aiur_fn_129( let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_129] = [__v_14]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_132] = [__v_14]; + if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_130: usize = 1; -const IN_130: usize = 1; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_133: usize = 1; +const IN_133: usize = 1; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -15815,79 +16218,79 @@ fn aiur_fn_130( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_130] = [__v_12]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_133] = [__v_12]; + if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_130] = [__v_12]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_133] = [__v_12]; + if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_131: usize = 2; -const IN_131: usize = 2; -const OUT_131: usize = 2; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_134: usize = 2; +const IN_134: usize = 2; +const OUT_134: usize = 2; +fn aiur_fn_134( + inp: [G; IN_134], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { +) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } - let __ret: [G; OUT_131] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } - let __ret: [G; OUT_131] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_5, __v_7]; + if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15897,75 +16300,75 @@ fn aiur_fn_131( }) } -const INPUT_SIZE_132: usize = 2; -const IN_132: usize = 2; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_135: usize = 2; +const IN_135: usize = 2; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_132] = [__v_2]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_2]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_133: usize = 2; -const IN_133: usize = 2; -const OUT_133: usize = 1; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_136: usize = 2; +const IN_136: usize = 2; +const OUT_136: usize = 1; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_133] = [__v_3]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_3]; + if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_134: usize = 2; -const IN_134: usize = 2; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_137: usize = 2; +const IN_137: usize = 2; +const OUT_137: usize = 1; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_134] = [__v_0]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_0]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_134] = [__v_4]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_4]; + if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -15975,19 +16378,19 @@ fn aiur_fn_134( }) } -const INPUT_SIZE_135: usize = 2; -const IN_135: usize = 2; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_138: usize = 2; +const IN_138: usize = 2; +const OUT_138: usize = 1; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -16004,8 +16407,8 @@ fn aiur_fn_135( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_135] = [__v_15]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_15]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16022,30 +16425,30 @@ fn aiur_fn_135( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_135] = [__v_21]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_21]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_135] = [__v_23]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_23]; + if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16060,15 +16463,15 @@ fn aiur_fn_135( }) } -const INPUT_SIZE_136: usize = 16; -const IN_136: usize = 16; -const OUT_136: usize = 8; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_139: usize = 16; +const IN_139: usize = 16; +const OUT_139: usize = 8; +fn aiur_fn_139( + inp: [G; IN_139], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16094,21 +16497,21 @@ fn aiur_fn_136( let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_137: usize = 16; -const IN_137: usize = 16; -const OUT_137: usize = 8; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_140: usize = 16; +const IN_140: usize = 16; +const OUT_140: usize = 8; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16134,21 +16537,21 @@ fn aiur_fn_137( let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_138: usize = 16; -const IN_138: usize = 16; -const OUT_138: usize = 8; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_141: usize = 16; +const IN_141: usize = 16; +const OUT_141: usize = 8; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16174,21 +16577,21 @@ fn aiur_fn_138( let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_141] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_139: usize = 2; -const IN_139: usize = 2; -const OUT_139: usize = 1; -fn aiur_fn_139( - inp: [G; IN_139], +const INPUT_SIZE_142: usize = 2; +const IN_142: usize = 2; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16208,8 +16611,8 @@ fn aiur_fn_139( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_139] = [__v_14]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_14]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16229,13 +16632,13 @@ fn aiur_fn_139( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_139] = [__v_24]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_24]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16244,11 +16647,11 @@ fn aiur_fn_139( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_139] = [__v_32]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_32]; + if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16263,15 +16666,15 @@ fn aiur_fn_139( }) } -const INPUT_SIZE_140: usize = 2; -const IN_140: usize = 2; -const OUT_140: usize = 1; -fn aiur_fn_140( - inp: [G; IN_140], +const INPUT_SIZE_143: usize = 2; +const IN_143: usize = 2; +const OUT_143: usize = 1; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16288,8 +16691,8 @@ fn aiur_fn_140( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_140] = [__v_1]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_1]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16306,13 +16709,13 @@ fn aiur_fn_140( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_140] = [__v_0]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_0]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16321,11 +16724,11 @@ fn aiur_fn_140( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_140] = [__v_32]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_32]; + if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16340,15 +16743,15 @@ fn aiur_fn_140( }) } -const INPUT_SIZE_141: usize = 2; -const IN_141: usize = 2; -const OUT_141: usize = 1; -fn aiur_fn_141( - inp: [G; IN_141], +const INPUT_SIZE_144: usize = 2; +const IN_144: usize = 2; +const OUT_144: usize = 1; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_141], ExecError> { +) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16365,8 +16768,8 @@ fn aiur_fn_141( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_141] = [__v_1]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_1]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16383,13 +16786,13 @@ fn aiur_fn_141( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_141] = [__v_0]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_0]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16398,11 +16801,11 @@ fn aiur_fn_141( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_141] = [__v_32]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_32]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -16417,15 +16820,15 @@ fn aiur_fn_141( }) } -const INPUT_SIZE_142: usize = 2; -const IN_142: usize = 2; -const OUT_142: usize = 1; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_145: usize = 2; +const IN_145: usize = 2; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16442,25 +16845,25 @@ fn aiur_fn_142( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_142] = [__v_16]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_16]; + if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_143: usize = 2; -const IN_143: usize = 2; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_146: usize = 2; +const IN_146: usize = 2; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: [G; IN_146], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16477,158 +16880,11 @@ fn aiur_fn_143( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_143] = [__v_16]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_144: usize = 0; -const IN_144: usize = 0; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(211); - let __v_1: G = G::from_u64(151); - 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_144] = [__v_32]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_145: usize = 0; -const IN_145: usize = 0; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(222); - let __v_1: G = G::from_u64(245); - 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_145] = [__v_32]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_146: usize = 0; -const IN_146: usize = 0; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(145); - let __v_1: G = G::from_u64(79); - 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_146] = [__v_32]; + let __ret: [G; OUT_146] = [__v_16]; if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -16644,38 +16900,38 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(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_0: G = G::from_u64(80); + let __v_1: G = G::from_u64(229); + let __v_2: G = G::from_u64(214); + let __v_3: G = G::from_u64(157); + let __v_4: G = G::from_u64(128); + let __v_5: G = G::from_u64(107); + let __v_6: G = G::from_u64(193); + let __v_7: G = G::from_u64(198); + let __v_8: G = G::from_u64(22); + let __v_9: G = G::from_u64(202); + let __v_10: G = G::from_u64(206); + let __v_11: G = G::from_u64(66); + let __v_12: G = G::from_u64(48); + let __v_13: G = G::from_u64(201); + let __v_14: G = G::from_u64(130); + let __v_15: G = G::from_u64(160); + let __v_16: G = G::from_u64(238); + let __v_17: G = G::from_u64(91); + let __v_18: G = G::from_u64(53); + let __v_19: G = G::from_u64(11); + let __v_20: G = G::from_u64(62); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(59); + let __v_23: G = G::from_u64(26); + let __v_24: G = G::from_u64(21); + let __v_25: G = G::from_u64(128); + let __v_26: G = G::from_u64(29); + let __v_27: G = G::from_u64(247); + let __v_28: G = G::from_u64(127); + let __v_29: G = G::from_u64(192); + let __v_30: G = G::from_u64(12); + let __v_31: G = G::from_u64(140); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_147] = [__v_32]; if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16693,38 +16949,38 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(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_0: G = G::from_u64(140); + let __v_1: G = G::from_u64(9); + let __v_2: G = G::from_u64(202); + let __v_3: G = G::from_u64(100); + let __v_4: G = G::from_u64(75); + let __v_5: G = G::from_u64(16); + let __v_6: G = G::from_u64(222); + let __v_7: G = G::from_u64(202); + let __v_8: G = G::from_u64(209); + let __v_9: G = G::from_u64(88); + let __v_10: G = G::from_u64(211); + let __v_11: G = G::from_u64(112); + let __v_12: G = G::from_u64(6); + let __v_13: G = G::from_u64(232); + let __v_14: G = G::from_u64(28); + let __v_15: G = G::from_u64(220); + let __v_16: G = G::from_u64(27); + let __v_17: G = G::from_u64(132); + let __v_18: G = G::from_u64(118); + let __v_19: G = G::from_u64(19); + let __v_20: G = G::from_u64(18); + let __v_21: G = G::from_u64(38); + let __v_22: G = G::from_u64(5); + let __v_23: G = G::from_u64(70); + let __v_24: G = G::from_u64(68); + let __v_25: G = G::from_u64(154); + let __v_26: G = G::from_u64(160); + let __v_27: G = G::from_u64(46); + let __v_28: G = G::from_u64(52); + let __v_29: G = G::from_u64(59); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(12); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_148] = [__v_32]; if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16742,38 +16998,38 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(182); - let __v_1: G = G::from_u64(187); - let __v_2: G = G::from_u64(172); - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(200); - let __v_5: G = G::from_u64(228); - let __v_6: G = G::from_u64(111); - let __v_7: G = G::from_u64(139); - let __v_8: G = G::from_u64(134); - let __v_9: G = G::from_u64(64); - let __v_10: G = G::from_u64(41); - let __v_11: G = G::from_u64(143); - let __v_12: G = G::from_u64(76); - let __v_13: G = G::from_u64(154); - let __v_14: G = G::from_u64(200); - let __v_15: G = G::from_u64(148); - let __v_16: G = G::from_u64(203); - let __v_17: G = G::from_u64(205); - let __v_18: G = G::from_u64(1); - let __v_19: G = G::from_u64(1); - let __v_20: G = G::from_u64(3); - let __v_21: G = G::from_u64(94); - let __v_22: G = G::from_u64(221); - let __v_23: G = G::from_u64(84); - let __v_24: G = G::from_u64(63); - let __v_25: G = G::from_u64(124); - let __v_26: G = G::from_u64(67); - let __v_27: G = G::from_u64(78); - let __v_28: G = G::from_u64(44); - let __v_29: G = G::from_u64(159); - let __v_30: G = G::from_u64(233); - let __v_31: G = G::from_u64(38); + let __v_0: G = G::from_u64(252); + let __v_1: G = G::from_u64(233); + let __v_2: G = G::from_u64(22); + let __v_3: G = G::from_u64(207); + let __v_4: G = G::from_u64(60); + let __v_5: G = G::from_u64(109); + let __v_6: G = G::from_u64(208); + let __v_7: G = G::from_u64(26); + let __v_8: G = G::from_u64(216); + let __v_9: G = G::from_u64(198); + let __v_10: G = G::from_u64(211); + let __v_11: G = G::from_u64(134); + let __v_12: G = G::from_u64(65); + let __v_13: G = G::from_u64(188); + let __v_14: G = G::from_u64(167); + let __v_15: G = G::from_u64(179); + let __v_16: G = G::from_u64(238); + let __v_17: G = G::from_u64(172); + let __v_18: G = G::from_u64(91); + let __v_19: G = G::from_u64(201); + let __v_20: G = G::from_u64(59); + let __v_21: G = G::from_u64(53); + let __v_22: G = G::from_u64(41); + let __v_23: G = G::from_u64(173); + let __v_24: G = G::from_u64(120); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(118); + let __v_27: G = G::from_u64(139); + let __v_28: G = G::from_u64(52); + let __v_29: G = G::from_u64(7); + let __v_30: G = G::from_u64(214); + let __v_31: G = G::from_u64(78); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_32]; if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16791,38 +17047,38 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(188); - let __v_1: G = G::from_u64(176); - let __v_2: G = G::from_u64(155); - let __v_3: G = G::from_u64(164); - let __v_4: G = G::from_u64(63); - let __v_5: G = G::from_u64(139); - let __v_6: G = G::from_u64(218); - let __v_7: G = G::from_u64(230); - let __v_8: G = G::from_u64(92); - let __v_9: G = G::from_u64(86); - let __v_10: G = G::from_u64(164); - let __v_11: G = G::from_u64(127); - let __v_12: G = G::from_u64(247); - let __v_13: G = G::from_u64(123); - let __v_14: G = G::from_u64(80); - let __v_15: G = G::from_u64(180); - let __v_16: G = G::from_u64(46); - let __v_17: G = G::from_u64(222); - let __v_18: G = G::from_u64(18); - let __v_19: G = G::from_u64(15); - let __v_20: G = G::from_u64(188); - let __v_21: G = G::from_u64(219); - let __v_22: G = G::from_u64(168); - let __v_23: G = G::from_u64(70); - let __v_24: G = G::from_u64(158); - let __v_25: G = G::from_u64(121); - let __v_26: G = G::from_u64(154); - let __v_27: G = G::from_u64(33); - let __v_28: G = G::from_u64(241); - let __v_29: G = G::from_u64(47); - let __v_30: G = G::from_u64(211); - let __v_31: G = G::from_u64(137); + let __v_0: G = G::from_u64(72); + let __v_1: G = G::from_u64(120); + let __v_2: G = G::from_u64(107); + let __v_3: G = G::from_u64(127); + let __v_4: G = G::from_u64(122); + let __v_5: G = G::from_u64(220); + let __v_6: G = G::from_u64(99); + let __v_7: G = G::from_u64(42); + let __v_8: G = G::from_u64(227); + let __v_9: G = G::from_u64(80); + let __v_10: G = G::from_u64(89); + let __v_11: G = G::from_u64(243); + let __v_12: G = G::from_u64(253); + let __v_13: G = G::from_u64(24); + let __v_14: G = G::from_u64(29); + let __v_15: G = G::from_u64(243); + let __v_16: G = G::from_u64(45); + let __v_17: G = G::from_u64(158); + let __v_18: G = G::from_u64(92); + let __v_19: G = G::from_u64(199); + let __v_20: G = G::from_u64(54); + let __v_21: G = G::from_u64(12); + let __v_22: G = G::from_u64(79); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(44); + let __v_25: G = G::from_u64(62); + let __v_26: G = G::from_u64(139); + let __v_27: G = G::from_u64(17); + let __v_28: G = G::from_u64(129); + let __v_29: G = G::from_u64(161); + let __v_30: G = G::from_u64(83); + let __v_31: G = G::from_u64(155); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_150] = [__v_32]; if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16840,38 +17096,38 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(116); - let __v_1: G = G::from_u64(237); - let __v_2: G = G::from_u64(31); - let __v_3: G = G::from_u64(185); - let __v_4: G = G::from_u64(169); - let __v_5: G = G::from_u64(191); - let __v_6: G = G::from_u64(153); - let __v_7: G = G::from_u64(208); - let __v_8: G = G::from_u64(176); - let __v_9: G = G::from_u64(45); - let __v_10: G = G::from_u64(190); - let __v_11: G = G::from_u64(254); - let __v_12: G = G::from_u64(4); - let __v_13: G = G::from_u64(36); - let __v_14: G = G::from_u64(100); - let __v_15: G = G::from_u64(205); - let __v_16: G = G::from_u64(113); - let __v_17: G = G::from_u64(83); - let __v_18: G = G::from_u64(1); - let __v_19: G = G::from_u64(133); - let __v_20: G = G::from_u64(154); - let __v_21: G = G::from_u64(112); - let __v_22: G = G::from_u64(51); - let __v_23: G = G::from_u64(122); - let __v_24: G = G::from_u64(153); - let __v_25: G = G::from_u64(52); - let __v_26: G = G::from_u64(75); - let __v_27: G = G::from_u64(231); - let __v_28: G = G::from_u64(98); - let __v_29: G = G::from_u64(220); - let __v_30: G = G::from_u64(190); - let __v_31: G = G::from_u64(16); + let __v_0: G = G::from_u64(207); + let __v_1: G = G::from_u64(201); + let __v_2: G = G::from_u64(52); + let __v_3: G = G::from_u64(253); + let __v_4: G = G::from_u64(109); + let __v_5: G = G::from_u64(83); + let __v_6: G = G::from_u64(165); + let __v_7: G = G::from_u64(178); + let __v_8: G = G::from_u64(59); + let __v_9: G = G::from_u64(106); + let __v_10: G = G::from_u64(59); + let __v_11: G = G::from_u64(48); + let __v_12: G = G::from_u64(208); + let __v_13: G = G::from_u64(33); + let __v_14: G = G::from_u64(101); + let __v_15: G = G::from_u64(253); + let __v_16: G = G::from_u64(170); + let __v_17: G = G::from_u64(87); + let __v_18: G = G::from_u64(78); + let __v_19: G = G::from_u64(59); + let __v_20: G = G::from_u64(94); + let __v_21: G = G::from_u64(177); + let __v_22: G = G::from_u64(57); + let __v_23: G = G::from_u64(38); + let __v_24: G = G::from_u64(187); + let __v_25: G = G::from_u64(22); + let __v_26: G = G::from_u64(110); + let __v_27: G = G::from_u64(100); + let __v_28: G = G::from_u64(134); + let __v_29: G = G::from_u64(252); + let __v_30: G = G::from_u64(14); + let __v_31: G = G::from_u64(80); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_151] = [__v_32]; if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16889,38 +17145,38 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(246); - let __v_1: G = G::from_u64(28); - let __v_2: G = G::from_u64(125); - let __v_3: G = G::from_u64(63); - let __v_4: G = G::from_u64(206); - let __v_5: G = G::from_u64(89); - let __v_6: G = G::from_u64(84); - let __v_7: G = G::from_u64(48); - let __v_8: G = G::from_u64(248); - let __v_9: G = G::from_u64(111); - let __v_10: G = G::from_u64(12); - let __v_11: G = G::from_u64(213); - let __v_12: G = G::from_u64(45); - let __v_13: G = G::from_u64(165); - let __v_14: G = G::from_u64(188); - let __v_15: G = G::from_u64(176); - let __v_16: G = G::from_u64(11); - let __v_17: G = G::from_u64(249); - let __v_18: G = G::from_u64(16); - let __v_19: G = G::from_u64(237); - let __v_20: G = G::from_u64(216); - let __v_21: G = G::from_u64(94); - let __v_22: G = G::from_u64(20); - let __v_23: G = G::from_u64(220); - let __v_24: G = G::from_u64(4); - let __v_25: G = G::from_u64(2); - let __v_26: G = G::from_u64(19); - let __v_27: G = G::from_u64(15); - let __v_28: G = G::from_u64(204); - let __v_29: G = G::from_u64(227); - let __v_30: G = G::from_u64(78); - let __v_31: G = G::from_u64(189); + let __v_0: G = G::from_u64(30); + let __v_1: G = G::from_u64(96); + let __v_2: G = G::from_u64(189); + let __v_3: G = G::from_u64(55); + let __v_4: G = G::from_u64(122); + let __v_5: G = G::from_u64(116); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(183); + let __v_8: G = G::from_u64(189); + let __v_9: G = G::from_u64(122); + let __v_10: G = G::from_u64(229); + let __v_11: G = G::from_u64(65); + let __v_12: G = G::from_u64(215); + let __v_13: G = G::from_u64(223); + let __v_14: G = G::from_u64(178); + let __v_15: G = G::from_u64(55); + let __v_16: G = G::from_u64(9); + let __v_17: G = G::from_u64(125); + let __v_18: G = G::from_u64(136); + let __v_19: G = G::from_u64(61); + let __v_20: G = G::from_u64(40); + let __v_21: G = G::from_u64(236); + let __v_22: G = G::from_u64(122); + let __v_23: G = G::from_u64(173); + let __v_24: G = G::from_u64(215); + let __v_25: G = G::from_u64(50); + let __v_26: G = G::from_u64(192); + let __v_27: G = G::from_u64(103); + let __v_28: G = G::from_u64(78); + let __v_29: G = G::from_u64(13); + let __v_30: G = G::from_u64(185); + let __v_31: G = G::from_u64(100); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_152] = [__v_32]; if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16938,38 +17194,38 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(172); - let __v_1: G = G::from_u64(156); - let __v_2: G = G::from_u64(114); - let __v_3: G = G::from_u64(49); - let __v_4: G = G::from_u64(149); - let __v_5: G = G::from_u64(81); - let __v_6: G = G::from_u64(245); - let __v_7: G = G::from_u64(99); - let __v_8: G = G::from_u64(127); - let __v_9: G = G::from_u64(124); - let __v_10: G = G::from_u64(81); - let __v_11: G = G::from_u64(199); - let __v_12: G = G::from_u64(11); - let __v_13: G = G::from_u64(230); - let __v_14: G = G::from_u64(218); - let __v_15: G = G::from_u64(143); - let __v_16: G = G::from_u64(214); - let __v_17: G = G::from_u64(106); - let __v_18: G = G::from_u64(129); - let __v_19: G = G::from_u64(131); - let __v_20: G = G::from_u64(124); - let __v_21: G = G::from_u64(158); - let __v_22: G = G::from_u64(181); - let __v_23: G = G::from_u64(12); - let __v_24: G = G::from_u64(63); - let __v_25: G = G::from_u64(213); - let __v_26: G = G::from_u64(14); - let __v_27: G = G::from_u64(207); - let __v_28: G = G::from_u64(140); - let __v_29: G = G::from_u64(187); - let __v_30: G = G::from_u64(192); - let __v_31: G = G::from_u64(112); + let __v_0: G = G::from_u64(13); + let __v_1: G = G::from_u64(116); + let __v_2: G = G::from_u64(186); + let __v_3: G = G::from_u64(133); + let __v_4: G = G::from_u64(249); + let __v_5: G = G::from_u64(116); + let __v_6: G = G::from_u64(154); + let __v_7: G = G::from_u64(12); + let __v_8: G = G::from_u64(37); + let __v_9: G = G::from_u64(170); + let __v_10: G = G::from_u64(106); + let __v_11: G = G::from_u64(43); + let __v_12: G = G::from_u64(112); + let __v_13: G = G::from_u64(52); + let __v_14: G = G::from_u64(142); + let __v_15: G = G::from_u64(87); + let __v_16: G = G::from_u64(231); + let __v_17: G = G::from_u64(9); + let __v_18: G = G::from_u64(131); + let __v_19: G = G::from_u64(31); + let __v_20: G = G::from_u64(183); + let __v_21: G = G::from_u64(204); + let __v_22: G = G::from_u64(5); + let __v_23: G = G::from_u64(34); + let __v_24: G = G::from_u64(159); + let __v_25: G = G::from_u64(236); + let __v_26: G = G::from_u64(215); + let __v_27: G = G::from_u64(214); + let __v_28: G = G::from_u64(106); + let __v_29: G = G::from_u64(223); + let __v_30: G = G::from_u64(24); + let __v_31: G = G::from_u64(77); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_153] = [__v_32]; if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -16987,38 +17243,38 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(159); - let __v_1: G = G::from_u64(44); - let __v_2: G = G::from_u64(164); - let __v_3: G = G::from_u64(227); - let __v_4: G = G::from_u64(222); - let __v_5: G = G::from_u64(58); - let __v_6: G = G::from_u64(121); - let __v_7: G = G::from_u64(79); - let __v_8: G = G::from_u64(103); - let __v_9: G = G::from_u64(219); - let __v_10: G = G::from_u64(100); - let __v_11: G = G::from_u64(132); - let __v_12: G = G::from_u64(157); - let __v_13: G = G::from_u64(213); - let __v_14: G = G::from_u64(119); - let __v_15: G = G::from_u64(192); - let __v_16: G = G::from_u64(102); - let __v_17: G = G::from_u64(229); - let __v_18: G = G::from_u64(97); - let __v_19: G = G::from_u64(66); - let __v_20: G = G::from_u64(32); - let __v_21: G = G::from_u64(111); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(188); - let __v_24: G = G::from_u64(114); - let __v_25: G = G::from_u64(78); - let __v_26: G = G::from_u64(75); - let __v_27: G = G::from_u64(141); - let __v_28: G = G::from_u64(182); - let __v_29: G = G::from_u64(242); - let __v_30: G = G::from_u64(15); - let __v_31: G = G::from_u64(91); + let __v_0: G = G::from_u64(197); + let __v_1: G = G::from_u64(190); + let __v_2: G = G::from_u64(246); + let __v_3: G = G::from_u64(190); + let __v_4: G = G::from_u64(108); + let __v_5: G = G::from_u64(63); + let __v_6: G = G::from_u64(220); + let __v_7: G = G::from_u64(82); + let __v_8: G = G::from_u64(4); + let __v_9: G = G::from_u64(84); + let __v_10: G = G::from_u64(193); + let __v_11: G = G::from_u64(30); + let __v_12: G = G::from_u64(153); + let __v_13: G = G::from_u64(80); + let __v_14: G = G::from_u64(235); + let __v_15: G = G::from_u64(47); + let __v_16: G = G::from_u64(26); + let __v_17: G = G::from_u64(108); + let __v_18: G = G::from_u64(146); + let __v_19: G = G::from_u64(244); + let __v_20: G = G::from_u64(26); + let __v_21: G = G::from_u64(100); + let __v_22: G = G::from_u64(107); + let __v_23: G = G::from_u64(92); + let __v_24: G = G::from_u64(161); + let __v_25: G = G::from_u64(104); + let __v_26: G = G::from_u64(255); + let __v_27: G = G::from_u64(25); + let __v_28: G = G::from_u64(143); + let __v_29: G = G::from_u64(19); + let __v_30: G = G::from_u64(197); + let __v_31: G = G::from_u64(90); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_154] = [__v_32]; if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17036,38 +17292,38 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(25); - let __v_1: G = G::from_u64(125); - let __v_2: G = G::from_u64(60); - let __v_3: G = G::from_u64(126); - let __v_4: G = G::from_u64(156); - let __v_5: G = G::from_u64(224); - let __v_6: G = G::from_u64(148); - let __v_7: G = G::from_u64(156); - let __v_8: G = G::from_u64(82); - let __v_9: G = G::from_u64(239); - let __v_10: G = G::from_u64(152); - let __v_11: G = G::from_u64(245); - let __v_12: G = G::from_u64(11); - let __v_13: G = G::from_u64(88); - let __v_14: G = G::from_u64(221); - let __v_15: G = G::from_u64(185); - let __v_16: G = G::from_u64(66); - let __v_17: G = G::from_u64(219); + let __v_0: G = G::from_u64(188); + let __v_1: G = G::from_u64(97); + let __v_2: G = G::from_u64(193); + let __v_3: G = G::from_u64(15); + let __v_4: G = G::from_u64(204); + let __v_5: G = G::from_u64(166); + let __v_6: G = G::from_u64(65); + let __v_7: G = G::from_u64(82); + let __v_8: G = G::from_u64(35); + let __v_9: G = G::from_u64(237); + let __v_10: G = G::from_u64(151); + let __v_11: G = G::from_u64(188); + let __v_12: G = G::from_u64(174); + let __v_13: G = G::from_u64(33); + let __v_14: G = G::from_u64(203); + let __v_15: G = G::from_u64(153); + let __v_16: G = G::from_u64(212); + let __v_17: G = G::from_u64(131); let __v_18: G = G::from_u64(109); - let __v_19: G = G::from_u64(54); - let __v_20: G = G::from_u64(118); - let __v_21: G = G::from_u64(64); - let __v_22: G = G::from_u64(214); - let __v_23: G = G::from_u64(251); - let __v_24: G = G::from_u64(111); - let __v_25: G = G::from_u64(73); - let __v_26: G = G::from_u64(171); - let __v_27: G = G::from_u64(145); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(123); + let __v_21: G = G::from_u64(7); + let __v_22: G = G::from_u64(134); + let __v_23: G = G::from_u64(162); + let __v_24: G = G::from_u64(252); + let __v_25: G = G::from_u64(92); + let __v_26: G = G::from_u64(89); + let __v_27: G = G::from_u64(5); let __v_28: G = G::from_u64(248); - let __v_29: G = G::from_u64(47); - let __v_30: G = G::from_u64(66); - let __v_31: G = G::from_u64(113); + let __v_29: G = G::from_u64(176); + let __v_30: G = G::from_u64(75); + let __v_31: G = G::from_u64(162); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_155] = [__v_32]; if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17085,38 +17341,38 @@ fn aiur_fn_156( unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(7); - let __v_1: G = G::from_u64(19); - let __v_2: G = G::from_u64(64); - let __v_3: G = G::from_u64(90); - let __v_4: G = G::from_u64(104); - let __v_5: G = G::from_u64(157); - let __v_6: G = G::from_u64(33); - let __v_7: G = G::from_u64(85); - let __v_8: G = G::from_u64(168); - let __v_9: G = G::from_u64(65); - let __v_10: G = G::from_u64(35); - let __v_11: G = G::from_u64(160); - let __v_12: G = G::from_u64(246); - let __v_13: G = G::from_u64(57); - let __v_14: G = G::from_u64(92); - let __v_15: G = G::from_u64(49); - let __v_16: G = G::from_u64(198); - let __v_17: G = G::from_u64(250); - let __v_18: G = G::from_u64(85); - let __v_19: G = G::from_u64(193); - let __v_20: G = G::from_u64(173); - let __v_21: G = G::from_u64(144); - let __v_22: G = G::from_u64(95); - let __v_23: G = G::from_u64(197); - let __v_24: G = G::from_u64(86); - let __v_25: G = G::from_u64(99); - let __v_26: G = G::from_u64(172); - let __v_27: G = G::from_u64(247); - let __v_28: G = G::from_u64(215); - let __v_29: G = G::from_u64(87); - let __v_30: G = G::from_u64(127); - let __v_31: G = G::from_u64(87); + let __v_0: G = G::from_u64(212); + let __v_1: G = G::from_u64(53); + let __v_2: G = G::from_u64(161); + let __v_3: G = G::from_u64(94); + let __v_4: G = G::from_u64(111); + let __v_5: G = G::from_u64(34); + let __v_6: G = G::from_u64(47); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(107); + let __v_9: G = G::from_u64(97); + let __v_10: G = G::from_u64(48); + let __v_11: G = G::from_u64(250); + let __v_12: G = G::from_u64(118); + let __v_13: G = G::from_u64(76); + let __v_14: G = G::from_u64(127); + let __v_15: G = G::from_u64(190); + let __v_16: G = G::from_u64(152); + let __v_17: G = G::from_u64(116); + let __v_18: G = G::from_u64(111); + let __v_19: G = G::from_u64(121); + let __v_20: G = G::from_u64(142); + let __v_21: G = G::from_u64(151); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(39); + let __v_24: G = G::from_u64(166); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(122); + let __v_27: G = G::from_u64(23); + let __v_28: G = G::from_u64(231); + let __v_29: G = G::from_u64(79); + let __v_30: G = G::from_u64(114); + let __v_31: G = G::from_u64(39); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_156] = [__v_32]; if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17134,38 +17390,38 @@ fn aiur_fn_157( unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(131); - let __v_1: G = G::from_u64(227); - let __v_2: G = G::from_u64(206); - let __v_3: G = G::from_u64(138); - let __v_4: G = G::from_u64(116); - let __v_5: G = G::from_u64(117); - let __v_6: G = G::from_u64(32); - let __v_7: G = G::from_u64(204); - let __v_8: G = G::from_u64(36); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(13); - let __v_11: G = G::from_u64(172); - let __v_12: G = G::from_u64(249); - let __v_13: G = G::from_u64(189); - let __v_14: G = G::from_u64(19); - let __v_15: G = G::from_u64(105); - let __v_16: G = G::from_u64(70); - let __v_17: G = G::from_u64(126); - let __v_18: G = G::from_u64(73); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(232); - let __v_21: G = G::from_u64(170); - let __v_22: G = G::from_u64(170); - let __v_23: G = G::from_u64(67); - let __v_24: G = G::from_u64(62); - let __v_25: G = G::from_u64(27); - let __v_26: G = G::from_u64(67); - let __v_27: G = G::from_u64(142); - let __v_28: G = G::from_u64(28); - let __v_29: G = G::from_u64(173); - let __v_30: G = G::from_u64(124); - let __v_31: G = G::from_u64(164); + let __v_0: G = G::from_u64(62); + let __v_1: G = G::from_u64(19); + let __v_2: G = G::from_u64(252); + let __v_3: G = G::from_u64(26); + let __v_4: G = G::from_u64(7); + let __v_5: G = G::from_u64(126); + let __v_6: G = G::from_u64(182); + let __v_7: G = G::from_u64(146); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(64); + let __v_10: G = G::from_u64(172); + let __v_11: G = G::from_u64(190); + let __v_12: G = G::from_u64(212); + let __v_13: G = G::from_u64(166); + let __v_14: G = G::from_u64(173); + let __v_15: G = G::from_u64(174); + let __v_16: G = G::from_u64(37); + let __v_17: G = G::from_u64(92); + let __v_18: G = G::from_u64(12); + let __v_19: G = G::from_u64(187); + let __v_20: G = G::from_u64(186); + let __v_21: G = G::from_u64(154); + let __v_22: G = G::from_u64(60); + let __v_23: G = G::from_u64(31); + let __v_24: G = G::from_u64(13); + let __v_25: G = G::from_u64(226); + let __v_26: G = G::from_u64(149); + let __v_27: G = G::from_u64(115); + let __v_28: G = G::from_u64(177); + let __v_29: G = G::from_u64(151); + let __v_30: G = G::from_u64(203); + let __v_31: G = G::from_u64(14); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_157] = [__v_32]; if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17183,38 +17439,38 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(135); - let __v_1: G = G::from_u64(91); - let __v_2: G = G::from_u64(232); - let __v_3: G = G::from_u64(216); - let __v_4: G = G::from_u64(174); - let __v_5: G = G::from_u64(95); - let __v_6: G = G::from_u64(51); - let __v_7: G = G::from_u64(32); - let __v_8: G = G::from_u64(3); - let __v_9: G = G::from_u64(236); - let __v_10: G = G::from_u64(43); - let __v_11: G = G::from_u64(173); - let __v_12: G = G::from_u64(230); - let __v_13: G = G::from_u64(152); - let __v_14: G = G::from_u64(187); - let __v_15: G = G::from_u64(10); - let __v_16: G = G::from_u64(165); - let __v_17: G = G::from_u64(242); - let __v_18: G = G::from_u64(244); - let __v_19: G = G::from_u64(110); - let __v_20: G = G::from_u64(113); - let __v_21: G = G::from_u64(33); - let __v_22: G = G::from_u64(141); - let __v_23: G = G::from_u64(169); - let __v_24: G = G::from_u64(205); - let __v_25: G = G::from_u64(217); - let __v_26: G = G::from_u64(208); - let __v_27: G = G::from_u64(149); - let __v_28: G = G::from_u64(6); - let __v_29: G = G::from_u64(232); - let __v_30: G = G::from_u64(76); - let __v_31: G = G::from_u64(16); + let __v_0: G = G::from_u64(153); + let __v_1: G = G::from_u64(112); + let __v_2: G = G::from_u64(244); + let __v_3: G = G::from_u64(2); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(112); + let __v_6: G = G::from_u64(232); + let __v_7: G = G::from_u64(163); + let __v_8: G = G::from_u64(20); + let __v_9: G = G::from_u64(111); + let __v_10: G = G::from_u64(191); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(118); + let __v_13: G = G::from_u64(249); + let __v_14: G = G::from_u64(73); + let __v_15: G = G::from_u64(170); + let __v_16: G = G::from_u64(100); + let __v_17: G = G::from_u64(178); + let __v_18: G = G::from_u64(6); + let __v_19: G = G::from_u64(222); + let __v_20: G = G::from_u64(155); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(87); + let __v_23: G = G::from_u64(180); + let __v_24: G = G::from_u64(105); + let __v_25: G = G::from_u64(253); + let __v_26: G = G::from_u64(227); + let __v_27: G = G::from_u64(87); + let __v_28: G = G::from_u64(183); + let __v_29: G = G::from_u64(21); + let __v_30: G = G::from_u64(241); + let __v_31: G = G::from_u64(156); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_158] = [__v_32]; if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17232,38 +17488,38 @@ fn aiur_fn_159( unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(225); - let __v_1: G = G::from_u64(238); - let __v_2: G = G::from_u64(76); - let __v_3: G = G::from_u64(120); - let __v_4: G = G::from_u64(163); - let __v_5: G = G::from_u64(144); - let __v_6: G = G::from_u64(100); - let __v_7: G = G::from_u64(100); - let __v_8: G = G::from_u64(250); - let __v_9: G = G::from_u64(140); - let __v_10: G = G::from_u64(23); - let __v_11: G = G::from_u64(236); - let __v_12: G = G::from_u64(46); - let __v_13: G = G::from_u64(208); - let __v_14: G = G::from_u64(192); - let __v_15: G = G::from_u64(191); - let __v_16: G = G::from_u64(102); - let __v_17: G = G::from_u64(219); - let __v_18: G = G::from_u64(59); - let __v_19: G = G::from_u64(65); - let __v_20: G = G::from_u64(45); - let __v_21: G = G::from_u64(155); - let __v_22: G = G::from_u64(28); - let __v_23: G = G::from_u64(95); - let __v_24: G = G::from_u64(49); - let __v_25: G = G::from_u64(251); - let __v_26: G = G::from_u64(167); - let __v_27: G = G::from_u64(187); - let __v_28: G = G::from_u64(151); - let __v_29: G = G::from_u64(74); - let __v_30: G = G::from_u64(147); - let __v_31: G = G::from_u64(229); + let __v_0: G = G::from_u64(134); + let __v_1: G = G::from_u64(127); + let __v_2: G = G::from_u64(142); + let __v_3: G = G::from_u64(157); + let __v_4: G = G::from_u64(251); + let __v_5: G = G::from_u64(117); + let __v_6: G = G::from_u64(34); + let __v_7: G = G::from_u64(101); + let __v_8: G = G::from_u64(186); + let __v_9: G = G::from_u64(71); + let __v_10: G = G::from_u64(66); + let __v_11: G = G::from_u64(54); + let __v_12: G = G::from_u64(139); + let __v_13: G = G::from_u64(106); + let __v_14: G = G::from_u64(250); + let __v_15: G = G::from_u64(84); + let __v_16: G = G::from_u64(106); + let __v_17: G = G::from_u64(228); + let __v_18: G = G::from_u64(226); + let __v_19: G = G::from_u64(64); + let __v_20: G = G::from_u64(252); + let __v_21: G = G::from_u64(90); + let __v_22: G = G::from_u64(198); + let __v_23: G = G::from_u64(155); + let __v_24: G = G::from_u64(74); + let __v_25: G = G::from_u64(78); + let __v_26: G = G::from_u64(134); + let __v_27: G = G::from_u64(216); + let __v_28: G = G::from_u64(90); + let __v_29: G = G::from_u64(110); + let __v_30: G = G::from_u64(70); + let __v_31: G = G::from_u64(246); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_159] = [__v_32]; if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17281,38 +17537,38 @@ fn aiur_fn_160( unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(191); - let __v_1: G = G::from_u64(5); - let __v_2: G = G::from_u64(142); - let __v_3: G = G::from_u64(228); - let __v_4: G = G::from_u64(70); - let __v_5: G = G::from_u64(82); - let __v_6: G = G::from_u64(122); - let __v_7: G = G::from_u64(246); - let __v_8: G = G::from_u64(236); - let __v_9: G = G::from_u64(116); - let __v_10: G = G::from_u64(146); - let __v_11: G = G::from_u64(35); - let __v_12: G = G::from_u64(117); - let __v_13: G = G::from_u64(45); - let __v_14: G = G::from_u64(7); - let __v_15: G = G::from_u64(230); - let __v_16: G = G::from_u64(215); - let __v_17: G = G::from_u64(194); - let __v_18: G = G::from_u64(223); - let __v_19: G = G::from_u64(141); - let __v_20: G = G::from_u64(192); - let __v_21: G = G::from_u64(160); - let __v_22: G = G::from_u64(119); - let __v_23: G = G::from_u64(141); - let __v_24: G = G::from_u64(147); - let __v_25: G = G::from_u64(79); - let __v_26: G = G::from_u64(136); - let __v_27: G = G::from_u64(90); - let __v_28: G = G::from_u64(232); - let __v_29: G = G::from_u64(38); - let __v_30: G = G::from_u64(125); - let __v_31: G = G::from_u64(87); + let __v_0: G = G::from_u64(33); + let __v_1: G = G::from_u64(212); + let __v_2: G = G::from_u64(218); + let __v_3: G = G::from_u64(204); + let __v_4: G = G::from_u64(15); + let __v_5: G = G::from_u64(64); + let __v_6: G = G::from_u64(107); + let __v_7: G = G::from_u64(49); + let __v_8: G = G::from_u64(224); + let __v_9: G = G::from_u64(68); + let __v_10: G = G::from_u64(251); + let __v_11: G = G::from_u64(244); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(152); + let __v_14: G = G::from_u64(122); + let __v_15: G = G::from_u64(51); + let __v_16: G = G::from_u64(45); + let __v_17: G = G::from_u64(216); + let __v_18: G = G::from_u64(180); + let __v_19: G = G::from_u64(36); + let __v_20: G = G::from_u64(79); + let __v_21: G = G::from_u64(125); + let __v_22: G = G::from_u64(158); + let __v_23: G = G::from_u64(98); + let __v_24: G = G::from_u64(176); + let __v_25: G = G::from_u64(134); + let __v_26: G = G::from_u64(80); + let __v_27: G = G::from_u64(20); + let __v_28: G = G::from_u64(116); + let __v_29: G = G::from_u64(130); + let __v_30: G = G::from_u64(85); + let __v_31: G = G::from_u64(68); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_160] = [__v_32]; if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17330,38 +17586,38 @@ fn aiur_fn_161( unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(194); - let __v_1: G = G::from_u64(254); - let __v_2: G = G::from_u64(94); - let __v_3: G = G::from_u64(218); - let __v_4: G = G::from_u64(30); - let __v_5: G = G::from_u64(85); - let __v_6: G = G::from_u64(146); - let __v_7: G = G::from_u64(54); - let __v_8: G = G::from_u64(191); - let __v_9: G = G::from_u64(194); - let __v_10: G = G::from_u64(167); - let __v_11: G = G::from_u64(164); - let __v_12: G = G::from_u64(125); - let __v_13: G = G::from_u64(176); - let __v_14: G = G::from_u64(202); - let __v_15: G = G::from_u64(108); - let __v_16: G = G::from_u64(247); - let __v_17: G = G::from_u64(130); - let __v_18: G = G::from_u64(247); - let __v_19: G = G::from_u64(182); - let __v_20: G = G::from_u64(155); - let __v_21: G = G::from_u64(221); - let __v_22: G = G::from_u64(150); - let __v_23: G = G::from_u64(50); - let __v_24: G = G::from_u64(55); - let __v_25: G = G::from_u64(208); - let __v_26: G = G::from_u64(136); - let __v_27: G = G::from_u64(159); - let __v_28: G = G::from_u64(191); - let __v_29: G = G::from_u64(154); - let __v_30: G = G::from_u64(75); - let __v_31: G = G::from_u64(7); + let __v_0: G = G::from_u64(135); + let __v_1: G = G::from_u64(133); + let __v_2: G = G::from_u64(153); + let __v_3: G = G::from_u64(233); + let __v_4: G = G::from_u64(245); + let __v_5: G = G::from_u64(187); + let __v_6: G = G::from_u64(204); + let __v_7: G = G::from_u64(185); + let __v_8: G = G::from_u64(66); + let __v_9: G = G::from_u64(35); + let __v_10: G = G::from_u64(47); + let __v_11: G = G::from_u64(249); + let __v_12: G = G::from_u64(59); + let __v_13: G = G::from_u64(98); + let __v_14: G = G::from_u64(198); + let __v_15: G = G::from_u64(61); + let __v_16: G = G::from_u64(180); + let __v_17: G = G::from_u64(235); + let __v_18: G = G::from_u64(223); + let __v_19: G = G::from_u64(98); + let __v_20: G = G::from_u64(185); + let __v_21: G = G::from_u64(249); + let __v_22: G = G::from_u64(35); + let __v_23: G = G::from_u64(121); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(163); + let __v_26: G = G::from_u64(112); + let __v_27: G = G::from_u64(73); + let __v_28: G = G::from_u64(244); + let __v_29: G = G::from_u64(34); + let __v_30: G = G::from_u64(173); + let __v_31: G = G::from_u64(134); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_161] = [__v_32]; if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17379,38 +17635,38 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(10); - let __v_1: G = G::from_u64(236); + let __v_0: G = G::from_u64(249); + let __v_1: G = G::from_u64(172); let __v_2: G = G::from_u64(146); - let __v_3: G = G::from_u64(49); - let __v_4: G = G::from_u64(62); - let __v_5: G = G::from_u64(89); - let __v_6: G = G::from_u64(141); - let __v_7: G = G::from_u64(95); - let __v_8: G = G::from_u64(203); - let __v_9: G = G::from_u64(93); - let __v_10: G = G::from_u64(207); - let __v_11: G = G::from_u64(11); - let __v_12: G = G::from_u64(128); - let __v_13: G = G::from_u64(57); - let __v_14: G = G::from_u64(156); - let __v_15: G = G::from_u64(105); - let __v_16: G = G::from_u64(235); - let __v_17: G = G::from_u64(246); - let __v_18: G = G::from_u64(164); - let __v_19: G = G::from_u64(59); - let __v_20: G = G::from_u64(158); - let __v_21: G = G::from_u64(233); - let __v_22: G = G::from_u64(122); - let __v_23: G = G::from_u64(62); - let __v_24: G = G::from_u64(86); - let __v_25: G = G::from_u64(20); - let __v_26: G = G::from_u64(54); - let __v_27: G = G::from_u64(185); - let __v_28: G = G::from_u64(242); - let __v_29: G = G::from_u64(185); + let __v_3: G = G::from_u64(161); + let __v_4: G = G::from_u64(19); + let __v_5: G = G::from_u64(136); + let __v_6: G = G::from_u64(167); + let __v_7: G = G::from_u64(205); + let __v_8: G = G::from_u64(202); + let __v_9: G = G::from_u64(34); + let __v_10: G = G::from_u64(154); + let __v_11: G = G::from_u64(128); + let __v_12: G = G::from_u64(36); + let __v_13: G = G::from_u64(32); + let __v_14: G = G::from_u64(133); + let __v_15: G = G::from_u64(84); + let __v_16: G = G::from_u64(254); + let __v_17: G = G::from_u64(179); + let __v_18: G = G::from_u64(45); + let __v_19: G = G::from_u64(108); + let __v_20: G = G::from_u64(10); + let __v_21: G = G::from_u64(58); + let __v_22: G = G::from_u64(247); + let __v_23: G = G::from_u64(74); + let __v_24: G = G::from_u64(123); + let __v_25: G = G::from_u64(193); + let __v_26: G = G::from_u64(44); + let __v_27: G = G::from_u64(40); + let __v_28: G = G::from_u64(185); + let __v_29: G = G::from_u64(73); let __v_30: G = G::from_u64(84); - let __v_31: G = G::from_u64(128); + let __v_31: G = G::from_u64(60); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_162] = [__v_32]; if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17428,38 +17684,38 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(89); - let __v_1: G = G::from_u64(228); - let __v_2: G = G::from_u64(125); - let __v_3: G = G::from_u64(113); - let __v_4: G = G::from_u64(215); - let __v_5: G = G::from_u64(60); - let __v_6: G = G::from_u64(84); - let __v_7: G = G::from_u64(78); - let __v_8: G = G::from_u64(225); - let __v_9: G = G::from_u64(164); - let __v_10: G = G::from_u64(237); - let __v_11: G = G::from_u64(240); - let __v_12: G = G::from_u64(126); - let __v_13: G = G::from_u64(159); - let __v_14: G = G::from_u64(255); - let __v_15: G = G::from_u64(245); - let __v_16: G = G::from_u64(66); - let __v_17: G = G::from_u64(203); - let __v_18: G = G::from_u64(117); - let __v_19: G = G::from_u64(126); - let __v_20: G = G::from_u64(115); - let __v_21: G = G::from_u64(150); - let __v_22: G = G::from_u64(81); - let __v_23: G = G::from_u64(169); - let __v_24: G = G::from_u64(205); - let __v_25: G = G::from_u64(69); - let __v_26: G = G::from_u64(58); - let __v_27: G = G::from_u64(240); - let __v_28: G = G::from_u64(61); - let __v_29: G = G::from_u64(61); - let __v_30: G = G::from_u64(206); - let __v_31: G = G::from_u64(66); + let __v_0: G = G::from_u64(223); + let __v_1: G = G::from_u64(56); + let __v_2: G = G::from_u64(53); + let __v_3: G = G::from_u64(47); + let __v_4: G = G::from_u64(250); + let __v_5: G = G::from_u64(29); + let __v_6: G = G::from_u64(110); + let __v_7: G = G::from_u64(41); + let __v_8: G = G::from_u64(35); + let __v_9: G = G::from_u64(73); + let __v_10: G = G::from_u64(37); + let __v_11: G = G::from_u64(159); + let __v_12: G = G::from_u64(51); + let __v_13: G = G::from_u64(235); + let __v_14: G = G::from_u64(103); + let __v_15: G = G::from_u64(128); + let __v_16: G = G::from_u64(36); + let __v_17: G = G::from_u64(187); + let __v_18: G = G::from_u64(100); + let __v_19: G = G::from_u64(107); + let __v_20: G = G::from_u64(53); + let __v_21: G = G::from_u64(134); + let __v_22: G = G::from_u64(56); + let __v_23: G = G::from_u64(160); + let __v_24: G = G::from_u64(45); + let __v_25: G = G::from_u64(161); + let __v_26: G = G::from_u64(153); + let __v_27: G = G::from_u64(94); + let __v_28: G = G::from_u64(212); + let __v_29: G = G::from_u64(171); + let __v_30: G = G::from_u64(235); + let __v_31: G = G::from_u64(9); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_163] = [__v_32]; if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17477,38 +17733,38 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(44); - let __v_1: G = G::from_u64(157); - let __v_2: G = G::from_u64(45); - let __v_3: G = G::from_u64(62); - let __v_4: G = G::from_u64(126); - let __v_5: G = G::from_u64(151); - let __v_6: G = G::from_u64(75); - let __v_7: G = G::from_u64(67); - let __v_8: G = G::from_u64(202); - let __v_9: G = G::from_u64(61); - let __v_10: G = G::from_u64(33); - let __v_11: G = G::from_u64(47); - let __v_12: G = G::from_u64(50); - let __v_13: G = G::from_u64(112); - let __v_14: G = G::from_u64(113); - let __v_15: G = G::from_u64(135); - let __v_16: G = G::from_u64(56); - let __v_17: G = G::from_u64(33); - let __v_18: G = G::from_u64(37); - let __v_19: G = G::from_u64(177); - let __v_20: G = G::from_u64(39); - let __v_21: G = G::from_u64(39); - let __v_22: G = G::from_u64(88); - let __v_23: G = G::from_u64(246); - let __v_24: G = G::from_u64(156); - let __v_25: G = G::from_u64(75); - let __v_26: G = G::from_u64(71); - let __v_27: G = G::from_u64(233); - let __v_28: G = G::from_u64(109); - let __v_29: G = G::from_u64(154); - let __v_30: G = G::from_u64(171); - let __v_31: G = G::from_u64(207); + let __v_0: G = G::from_u64(243); + let __v_1: G = G::from_u64(141); + let __v_2: G = G::from_u64(79); + let __v_3: G = G::from_u64(123); + let __v_4: G = G::from_u64(170); + let __v_5: G = G::from_u64(160); + let __v_6: G = G::from_u64(33); + let __v_7: G = G::from_u64(227); + let __v_8: G = G::from_u64(181); + let __v_9: G = G::from_u64(85); + let __v_10: G = G::from_u64(49); + let __v_11: G = G::from_u64(33); + let __v_12: G = G::from_u64(69); + let __v_13: G = G::from_u64(217); + let __v_14: G = G::from_u64(255); + let __v_15: G = G::from_u64(211); + let __v_16: G = G::from_u64(221); + let __v_17: G = G::from_u64(197); + let __v_18: G = G::from_u64(234); + let __v_19: G = G::from_u64(203); + let __v_20: G = G::from_u64(123); + let __v_21: G = G::from_u64(253); + let __v_22: G = G::from_u64(91); + let __v_23: G = G::from_u64(134); + let __v_24: G = G::from_u64(167); + let __v_25: G = G::from_u64(176); + let __v_26: G = G::from_u64(234); + let __v_27: G = G::from_u64(253); + let __v_28: G = G::from_u64(252); + let __v_29: G = G::from_u64(244); + let __v_30: G = G::from_u64(22); + let __v_31: G = G::from_u64(170); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_164] = [__v_32]; if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17526,38 +17782,38 @@ fn aiur_fn_165( unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(47); - let __v_1: G = G::from_u64(18); - let __v_2: G = G::from_u64(243); - let __v_3: G = G::from_u64(34); - let __v_4: G = G::from_u64(148); - let __v_5: G = G::from_u64(183); - let __v_6: G = G::from_u64(209); - let __v_7: G = G::from_u64(22); - let __v_8: G = G::from_u64(138); - let __v_9: G = G::from_u64(218); - let __v_10: G = G::from_u64(24); - let __v_11: G = G::from_u64(9); - let __v_12: G = G::from_u64(201); - let __v_13: G = G::from_u64(184); - let __v_14: G = G::from_u64(178); - let __v_15: G = G::from_u64(86); - let __v_16: G = G::from_u64(56); - let __v_17: G = G::from_u64(36); - let __v_18: G = G::from_u64(233); - let __v_19: G = G::from_u64(194); - let __v_20: G = G::from_u64(135); - let __v_21: G = G::from_u64(155); - let __v_22: G = G::from_u64(248); - let __v_23: G = G::from_u64(211); - let __v_24: G = G::from_u64(187); - let __v_25: G = G::from_u64(155); - let __v_26: G = G::from_u64(92); - let __v_27: G = G::from_u64(3); - let __v_28: G = G::from_u64(215); - let __v_29: G = G::from_u64(171); - let __v_30: G = G::from_u64(113); - let __v_31: G = G::from_u64(49); + let __v_0: G = G::from_u64(104); + let __v_1: G = G::from_u64(246); + let __v_2: G = G::from_u64(30); + let __v_3: G = G::from_u64(245); + let __v_4: G = G::from_u64(91); + let __v_5: G = G::from_u64(99); + let __v_6: G = G::from_u64(205); + let __v_7: G = G::from_u64(35); + let __v_8: G = G::from_u64(173); + let __v_9: G = G::from_u64(142); + let __v_10: G = G::from_u64(209); + let __v_11: G = G::from_u64(133); + let __v_12: G = G::from_u64(183); + let __v_13: G = G::from_u64(238); + let __v_14: G = G::from_u64(195); + let __v_15: G = G::from_u64(220); + let __v_16: G = G::from_u64(117); + let __v_17: G = G::from_u64(78); + let __v_18: G = G::from_u64(97); + let __v_19: G = G::from_u64(204); + let __v_20: G = G::from_u64(88); + let __v_21: G = G::from_u64(5); + let __v_22: G = G::from_u64(96); + let __v_23: G = G::from_u64(135); + let __v_24: G = G::from_u64(169); + let __v_25: G = G::from_u64(126); + let __v_26: G = G::from_u64(129); + let __v_27: G = G::from_u64(157); + let __v_28: G = G::from_u64(14); + let __v_29: G = G::from_u64(149); + let __v_30: G = G::from_u64(230); + let __v_31: G = G::from_u64(253); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_165] = [__v_32]; if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17575,38 +17831,38 @@ fn aiur_fn_166( unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(131); - let __v_1: G = G::from_u64(60); - let __v_2: G = G::from_u64(91); - let __v_3: G = G::from_u64(46); - let __v_4: G = G::from_u64(60); - let __v_5: G = G::from_u64(7); - let __v_6: G = G::from_u64(126); - let __v_7: G = G::from_u64(182); - let __v_8: G = G::from_u64(179); - let __v_9: G = G::from_u64(192); - let __v_10: G = G::from_u64(228); - let __v_11: G = G::from_u64(216); - let __v_12: G = G::from_u64(72); - let __v_13: G = G::from_u64(207); - let __v_14: G = G::from_u64(84); - let __v_15: G = G::from_u64(8); - let __v_16: G = G::from_u64(36); - let __v_17: G = G::from_u64(12); - let __v_18: G = G::from_u64(125); - let __v_19: G = G::from_u64(60); - let __v_20: G = G::from_u64(255); - let __v_21: G = G::from_u64(140); - let __v_22: G = G::from_u64(64); - let __v_23: G = G::from_u64(99); - let __v_24: G = G::from_u64(92); - let __v_25: G = G::from_u64(110); - let __v_26: G = G::from_u64(59); - let __v_27: G = G::from_u64(249); - let __v_28: G = G::from_u64(70); - let __v_29: G = G::from_u64(99); - let __v_30: G = G::from_u64(14); - let __v_31: G = G::from_u64(52); + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(71); + let __v_2: G = G::from_u64(242); + let __v_3: G = G::from_u64(187); + let __v_4: G = G::from_u64(232); + let __v_5: G = G::from_u64(145); + let __v_6: G = G::from_u64(184); + let __v_7: G = G::from_u64(37); + let __v_8: G = G::from_u64(196); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(39); + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(154); + let __v_13: G = G::from_u64(13); + let __v_14: G = G::from_u64(114); + let __v_15: G = G::from_u64(153); + let __v_16: G = G::from_u64(123); + let __v_17: G = G::from_u64(120); + let __v_18: G = G::from_u64(186); + let __v_19: G = G::from_u64(172); + let __v_20: G = G::from_u64(121); + let __v_21: G = G::from_u64(137); + let __v_22: G = G::from_u64(28); + let __v_23: G = G::from_u64(166); + let __v_24: G = G::from_u64(101); + let __v_25: G = G::from_u64(25); + let __v_26: G = G::from_u64(136); + let __v_27: G = G::from_u64(183); + let __v_28: G = G::from_u64(201); + let __v_29: G = G::from_u64(180); + let __v_30: G = G::from_u64(127); + let __v_31: G = G::from_u64(3); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_166] = [__v_32]; if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17624,38 +17880,38 @@ fn aiur_fn_167( unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(114); - let __v_1: G = G::from_u64(50); - let __v_2: G = G::from_u64(9); - let __v_3: G = G::from_u64(90); - let __v_4: G = G::from_u64(234); - let __v_5: G = G::from_u64(154); - let __v_6: G = G::from_u64(95); - let __v_7: G = G::from_u64(121); - let __v_8: G = G::from_u64(204); - let __v_9: G = G::from_u64(15); - let __v_10: G = G::from_u64(43); - let __v_11: G = G::from_u64(10); - let __v_12: G = G::from_u64(216); - let __v_13: G = G::from_u64(72); - let __v_14: G = G::from_u64(219); - let __v_15: G = G::from_u64(241); - let __v_16: G = G::from_u64(144); - let __v_17: G = G::from_u64(74); - let __v_18: G = G::from_u64(99); - let __v_19: G = G::from_u64(15); - let __v_20: G = G::from_u64(30); - let __v_21: G = G::from_u64(248); - let __v_22: G = G::from_u64(111); - let __v_23: G = G::from_u64(36); - let __v_24: G = G::from_u64(79); - let __v_25: G = G::from_u64(138); - let __v_26: G = G::from_u64(66); - let __v_27: G = G::from_u64(184); - let __v_28: G = G::from_u64(71); - let __v_29: G = G::from_u64(175); - let __v_30: G = G::from_u64(171); - let __v_31: G = G::from_u64(154); + let __v_0: G = G::from_u64(246); + let __v_1: G = G::from_u64(235); + let __v_2: G = G::from_u64(116); + let __v_3: G = G::from_u64(41); + let __v_4: G = G::from_u64(150); + let __v_5: G = G::from_u64(198); + let __v_6: G = G::from_u64(15); + let __v_7: G = G::from_u64(16); + let __v_8: G = G::from_u64(104); + let __v_9: G = G::from_u64(194); + let __v_10: G = G::from_u64(212); + let __v_11: G = G::from_u64(55); + let __v_12: G = G::from_u64(175); + let __v_13: G = G::from_u64(221); + let __v_14: G = G::from_u64(139); + let __v_15: G = G::from_u64(54); + let __v_16: G = G::from_u64(9); + let __v_17: G = G::from_u64(4); + let __v_18: G = G::from_u64(13); + let __v_19: G = G::from_u64(100); + let __v_20: G = G::from_u64(238); + let __v_21: G = G::from_u64(197); + let __v_22: G = G::from_u64(225); + let __v_23: G = G::from_u64(95); + let __v_24: G = G::from_u64(7); + let __v_25: G = G::from_u64(161); + let __v_26: G = G::from_u64(29); + let __v_27: G = G::from_u64(193); + let __v_28: G = G::from_u64(29); + let __v_29: G = G::from_u64(7); + let __v_30: G = G::from_u64(13); + let __v_31: G = G::from_u64(123); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_167] = [__v_32]; if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17673,38 +17929,38 @@ fn aiur_fn_168( unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(195); - let __v_1: G = G::from_u64(176); - let __v_2: G = G::from_u64(11); - let __v_3: G = G::from_u64(81); - let __v_4: G = G::from_u64(75); - let __v_5: G = G::from_u64(159); - let __v_6: G = G::from_u64(38); - let __v_7: G = G::from_u64(220); - let __v_8: G = G::from_u64(30); - let __v_9: G = G::from_u64(223); - let __v_10: G = G::from_u64(16); - let __v_11: G = G::from_u64(199); - let __v_12: G = G::from_u64(214); - let __v_13: G = G::from_u64(246); - let __v_14: G = G::from_u64(159); - let __v_15: G = G::from_u64(69); - let __v_16: G = G::from_u64(94); - let __v_17: G = G::from_u64(248); - let __v_18: G = G::from_u64(237); - let __v_19: G = G::from_u64(12); - let __v_20: G = G::from_u64(81); - let __v_21: G = G::from_u64(176); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(102); - let __v_24: G = G::from_u64(227); - let __v_25: G = G::from_u64(66); - let __v_26: G = G::from_u64(127); - let __v_27: G = G::from_u64(180); - let __v_28: G = G::from_u64(77); - let __v_29: G = G::from_u64(58); - let __v_30: G = G::from_u64(4); - let __v_31: G = G::from_u64(240); + let __v_0: G = G::from_u64(35); + let __v_1: G = G::from_u64(23); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(73); + let __v_4: G = G::from_u64(165); + let __v_5: G = G::from_u64(142); + let __v_6: G = G::from_u64(165); + let __v_7: G = G::from_u64(9); + let __v_8: G = G::from_u64(93); + let __v_9: G = G::from_u64(28); + let __v_10: G = G::from_u64(81); + let __v_11: G = G::from_u64(162); + let __v_12: G = G::from_u64(28); + let __v_13: G = G::from_u64(122); + let __v_14: G = G::from_u64(210); + let __v_15: G = G::from_u64(207); + let __v_16: G = G::from_u64(142); + let __v_17: G = G::from_u64(141); + let __v_18: G = G::from_u64(204); + let __v_19: G = G::from_u64(239); + let __v_20: G = G::from_u64(52); + let __v_21: G = G::from_u64(38); + let __v_22: G = G::from_u64(152); + let __v_23: G = G::from_u64(224); + let __v_24: G = G::from_u64(126); + let __v_25: G = G::from_u64(36); + let __v_26: G = G::from_u64(22); + let __v_27: G = G::from_u64(104); + let __v_28: G = G::from_u64(255); + let __v_29: G = G::from_u64(122); + let __v_30: G = G::from_u64(211); + let __v_31: G = G::from_u64(231); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_168] = [__v_32]; if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17722,38 +17978,38 @@ fn aiur_fn_169( unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(110); - let __v_1: G = G::from_u64(112); - let __v_2: G = G::from_u64(205); - let __v_3: G = G::from_u64(157); - let __v_4: G = G::from_u64(23); - let __v_5: G = G::from_u64(8); - let __v_6: G = G::from_u64(184); - let __v_7: G = G::from_u64(240); - let __v_8: G = G::from_u64(11); - let __v_9: G = G::from_u64(228); - let __v_10: G = G::from_u64(96); - let __v_11: G = G::from_u64(101); - let __v_12: G = G::from_u64(92); - let __v_13: G = G::from_u64(164); - let __v_14: G = G::from_u64(122); - let __v_15: G = G::from_u64(65); - let __v_16: G = G::from_u64(157); - let __v_17: G = G::from_u64(198); - let __v_18: G = G::from_u64(1); - let __v_19: G = G::from_u64(249); - let __v_20: G = G::from_u64(192); - let __v_21: G = G::from_u64(85); - let __v_22: G = G::from_u64(142); - let __v_23: G = G::from_u64(122); - let __v_24: G = G::from_u64(194); - let __v_25: G = G::from_u64(18); - let __v_26: G = G::from_u64(184); - let __v_27: G = G::from_u64(14); - let __v_28: G = G::from_u64(230); - let __v_29: G = G::from_u64(255); - let __v_30: G = G::from_u64(9); - let __v_31: G = G::from_u64(120); + let __v_0: G = G::from_u64(143); + let __v_1: G = G::from_u64(71); + let __v_2: G = G::from_u64(92); + let __v_3: G = G::from_u64(199); + let __v_4: G = G::from_u64(45); + let __v_5: G = G::from_u64(162); + let __v_6: G = G::from_u64(172); + let __v_7: G = G::from_u64(108); + let __v_8: G = G::from_u64(226); + let __v_9: G = G::from_u64(169); + let __v_10: G = G::from_u64(40); + let __v_11: G = G::from_u64(43); + let __v_12: G = G::from_u64(107); + let __v_13: G = G::from_u64(93); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(204); + let __v_16: G = G::from_u64(247); + let __v_17: G = G::from_u64(188); + let __v_18: G = G::from_u64(60); + let __v_19: G = G::from_u64(238); + let __v_20: G = G::from_u64(6); + let __v_21: G = G::from_u64(73); + let __v_22: G = G::from_u64(210); + let __v_23: G = G::from_u64(39); + let __v_24: G = G::from_u64(102); + let __v_25: G = G::from_u64(190); + let __v_26: G = G::from_u64(189); + let __v_27: G = G::from_u64(50); + let __v_28: G = G::from_u64(209); + let __v_29: G = G::from_u64(128); + let __v_30: G = G::from_u64(111); + let __v_31: G = G::from_u64(59); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_169] = [__v_32]; if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17771,38 +18027,38 @@ fn aiur_fn_170( unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(216); - let __v_1: G = G::from_u64(221); - let __v_2: G = G::from_u64(236); - let __v_3: G = G::from_u64(103); - let __v_4: G = G::from_u64(211); - let __v_5: G = G::from_u64(46); - let __v_6: G = G::from_u64(235); - let __v_7: G = G::from_u64(31); - let __v_8: G = G::from_u64(43); - let __v_9: G = G::from_u64(13); - let __v_10: G = G::from_u64(84); - let __v_11: G = G::from_u64(3); - let __v_12: G = G::from_u64(114); - let __v_13: G = G::from_u64(237); - let __v_14: G = G::from_u64(116); - let __v_15: G = G::from_u64(82); - let __v_16: G = G::from_u64(32); - let __v_17: G = G::from_u64(253); - let __v_18: G = G::from_u64(177); - let __v_19: G = G::from_u64(228); - let __v_20: G = G::from_u64(226); - let __v_21: G = G::from_u64(178); - let __v_22: G = G::from_u64(245); - let __v_23: G = G::from_u64(75); - let __v_24: G = G::from_u64(173); - let __v_25: G = G::from_u64(222); - let __v_26: G = G::from_u64(96); - let __v_27: G = G::from_u64(182); - let __v_28: G = G::from_u64(103); - let __v_29: G = G::from_u64(52); - let __v_30: G = G::from_u64(249); - let __v_31: G = G::from_u64(243); + let __v_0: G = G::from_u64(143); + let __v_1: G = G::from_u64(60); + let __v_2: G = G::from_u64(28); + let __v_3: G = G::from_u64(67); + let __v_4: G = G::from_u64(44); + let __v_5: G = G::from_u64(89); + let __v_6: G = G::from_u64(142); + let __v_7: G = G::from_u64(66); + let __v_8: G = G::from_u64(64); + let __v_9: G = G::from_u64(211); + let __v_10: G = G::from_u64(111); + let __v_11: G = G::from_u64(137); + let __v_12: G = G::from_u64(69); + let __v_13: G = G::from_u64(148); + let __v_14: G = G::from_u64(33); + let __v_15: G = G::from_u64(116); + let __v_16: G = G::from_u64(103); + let __v_17: G = G::from_u64(92); + let __v_18: G = G::from_u64(92); + let __v_19: G = G::from_u64(145); + let __v_20: G = G::from_u64(224); + let __v_21: G = G::from_u64(63); + let __v_22: G = G::from_u64(107); + let __v_23: G = G::from_u64(138); + let __v_24: G = G::from_u64(176); + let __v_25: G = G::from_u64(24); + let __v_26: G = G::from_u64(232); + let __v_27: G = G::from_u64(176); + let __v_28: G = G::from_u64(82); + let __v_29: G = G::from_u64(98); + let __v_30: G = G::from_u64(44); + let __v_31: G = G::from_u64(99); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_170] = [__v_32]; if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17820,38 +18076,38 @@ fn aiur_fn_171( unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(202); - let __v_1: G = G::from_u64(48); - let __v_2: G = G::from_u64(34); - let __v_3: G = G::from_u64(163); - let __v_4: G = G::from_u64(200); - let __v_5: G = G::from_u64(53); - let __v_6: G = G::from_u64(155); - let __v_7: G = G::from_u64(12); - let __v_8: G = G::from_u64(67); - let __v_9: G = G::from_u64(94); - let __v_10: G = G::from_u64(180); - let __v_11: G = G::from_u64(187); - let __v_12: G = G::from_u64(142); - let __v_13: G = G::from_u64(142); - let __v_14: G = G::from_u64(172); - let __v_15: G = G::from_u64(10); - let __v_16: G = G::from_u64(160); - let __v_17: G = G::from_u64(133); - let __v_18: G = G::from_u64(209); - let __v_19: G = G::from_u64(218); - let __v_20: G = G::from_u64(16); - let __v_21: G = G::from_u64(242); - let __v_22: G = G::from_u64(89); - let __v_23: G = G::from_u64(40); - let __v_24: G = G::from_u64(112); - let __v_25: G = G::from_u64(37); - let __v_26: G = G::from_u64(34); - let __v_27: G = G::from_u64(152); - let __v_28: G = G::from_u64(97); - let __v_29: G = G::from_u64(17); - let __v_30: G = G::from_u64(32); - let __v_31: G = G::from_u64(112); + let __v_0: G = G::from_u64(128); + let __v_1: G = G::from_u64(10); + let __v_2: G = G::from_u64(138); + let __v_3: G = G::from_u64(45); + let __v_4: G = G::from_u64(111); + let __v_5: G = G::from_u64(145); + let __v_6: G = G::from_u64(189); + let __v_7: G = G::from_u64(26); + let __v_8: G = G::from_u64(145); + let __v_9: G = G::from_u64(211); + let __v_10: G = G::from_u64(19); + let __v_11: G = G::from_u64(209); + let __v_12: G = G::from_u64(225); + let __v_13: G = G::from_u64(158); + let __v_14: G = G::from_u64(246); + let __v_15: G = G::from_u64(159); + let __v_16: G = G::from_u64(55); + let __v_17: G = G::from_u64(222); + let __v_18: G = G::from_u64(221); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(247); + let __v_21: G = G::from_u64(222); + let __v_22: G = G::from_u64(79); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(151); + let __v_25: G = G::from_u64(128); + let __v_26: G = G::from_u64(190); + let __v_27: G = G::from_u64(133); + let __v_28: G = G::from_u64(90); + let __v_29: G = G::from_u64(3); + let __v_30: G = G::from_u64(253); + let __v_31: G = G::from_u64(31); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_171] = [__v_32]; if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17869,38 +18125,38 @@ fn aiur_fn_172( unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(202); - let __v_1: G = G::from_u64(75); - let __v_2: G = G::from_u64(57); - let __v_3: G = G::from_u64(139); - let __v_4: G = G::from_u64(32); - let __v_5: G = G::from_u64(128); - let __v_6: G = G::from_u64(190); - let __v_7: G = G::from_u64(204); - let __v_8: G = G::from_u64(204); - let __v_9: G = G::from_u64(243); - let __v_10: G = G::from_u64(163); - let __v_11: G = G::from_u64(18); - let __v_12: G = G::from_u64(30); - let __v_13: G = G::from_u64(132); - let __v_14: G = G::from_u64(139); - let __v_15: G = G::from_u64(209); - let __v_16: G = G::from_u64(151); - let __v_17: G = G::from_u64(120); - let __v_18: G = G::from_u64(71); - let __v_19: G = G::from_u64(102); - let __v_20: G = G::from_u64(140); - let __v_21: G = G::from_u64(24); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(68); - let __v_24: G = G::from_u64(123); - let __v_25: G = G::from_u64(14); - let __v_26: G = G::from_u64(220); - let __v_27: G = G::from_u64(95); - let __v_28: G = G::from_u64(86); - let __v_29: G = G::from_u64(27); - let __v_30: G = G::from_u64(28); - let __v_31: G = G::from_u64(188); + let __v_0: G = G::from_u64(84); + let __v_1: G = G::from_u64(115); + let __v_2: G = G::from_u64(89); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(112); + let __v_5: G = G::from_u64(121); + let __v_6: G = G::from_u64(67); + let __v_7: G = G::from_u64(236); + let __v_8: G = G::from_u64(7); + let __v_9: G = G::from_u64(42); + let __v_10: G = G::from_u64(46); + let __v_11: G = G::from_u64(229); + let __v_12: G = G::from_u64(60); + let __v_13: G = G::from_u64(67); + let __v_14: G = G::from_u64(61); + let __v_15: G = G::from_u64(162); + let __v_16: G = G::from_u64(199); + let __v_17: G = G::from_u64(122); + let __v_18: G = G::from_u64(164); + let __v_19: G = G::from_u64(94); + let __v_20: G = G::from_u64(214); + let __v_21: G = G::from_u64(52); + let __v_22: G = G::from_u64(218); + let __v_23: G = G::from_u64(84); + let __v_24: G = G::from_u64(178); + let __v_25: G = G::from_u64(67); + let __v_26: G = G::from_u64(116); + let __v_27: G = G::from_u64(209); + let __v_28: G = G::from_u64(158); + let __v_29: G = G::from_u64(185); + let __v_30: G = G::from_u64(12); + let __v_31: G = G::from_u64(210); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_32]; if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -17917,6 +18173,153 @@ fn aiur_fn_173( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(27); + let __v_1: G = G::from_u64(89); + let __v_2: G = G::from_u64(17); + let __v_3: G = G::from_u64(73); + let __v_4: G = G::from_u64(21); + let __v_5: G = G::from_u64(141); + let __v_6: G = G::from_u64(137); + let __v_7: G = G::from_u64(105); + let __v_8: G = G::from_u64(55); + let __v_9: G = G::from_u64(238); + let __v_10: G = G::from_u64(191); + let __v_11: G = G::from_u64(213); + let __v_12: G = G::from_u64(50); + let __v_13: G = G::from_u64(50); + let __v_14: G = G::from_u64(181); + let __v_15: G = G::from_u64(174); + let __v_16: G = G::from_u64(138); + let __v_17: G = G::from_u64(75); + let __v_18: G = G::from_u64(205); + let __v_19: G = G::from_u64(178); + let __v_20: G = G::from_u64(90); + let __v_21: G = G::from_u64(104); + let __v_22: G = G::from_u64(17); + let __v_23: G = G::from_u64(201); + let __v_24: G = G::from_u64(107); + let __v_25: G = G::from_u64(217); + let __v_26: G = G::from_u64(65); + let __v_27: G = G::from_u64(20); + let __v_28: G = G::from_u64(169); + let __v_29: G = G::from_u64(248); + let __v_30: G = G::from_u64(190); + let __v_31: G = G::from_u64(213); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_173] = [__v_32]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_174: usize = 0; +const IN_174: usize = 0; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_174], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(114); + let __v_1: G = G::from_u64(198); + let __v_2: G = G::from_u64(212); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(83); + let __v_6: G = G::from_u64(121); + let __v_7: G = G::from_u64(136); + let __v_8: G = G::from_u64(80); + let __v_9: G = G::from_u64(169); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(87); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(139); + let __v_14: G = G::from_u64(135); + let __v_15: G = G::from_u64(206); + let __v_16: G = G::from_u64(238); + let __v_17: G = G::from_u64(14); + let __v_18: G = G::from_u64(52); + let __v_19: G = G::from_u64(25); + let __v_20: G = G::from_u64(92); + let __v_21: G = G::from_u64(9); + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(133); + let __v_24: G = G::from_u64(143); + let __v_25: G = G::from_u64(212); + let __v_26: G = G::from_u64(31); + let __v_27: G = G::from_u64(111); + let __v_28: G = G::from_u64(14); + let __v_29: G = G::from_u64(153); + let __v_30: G = G::from_u64(98); + let __v_31: G = G::from_u64(174); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_174] = [__v_32]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_175: usize = 0; +const IN_175: usize = 0; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_175], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(195); + let __v_1: G = G::from_u64(127); + let __v_2: G = G::from_u64(46); + let __v_3: G = G::from_u64(129); + let __v_4: G = G::from_u64(31); + let __v_5: G = G::from_u64(68); + let __v_6: G = G::from_u64(213); + let __v_7: G = G::from_u64(156); + let __v_8: G = G::from_u64(7); + let __v_9: G = G::from_u64(9); + let __v_10: G = G::from_u64(73); + let __v_11: G = G::from_u64(71); + let __v_12: G = G::from_u64(20); + let __v_13: G = G::from_u64(111); + let __v_14: G = G::from_u64(252); + let __v_15: G = G::from_u64(189); + let __v_16: G = G::from_u64(58); + let __v_17: G = G::from_u64(236); + let __v_18: G = G::from_u64(94); + let __v_19: G = G::from_u64(199); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(42); + let __v_22: G = G::from_u64(195); + let __v_23: G = G::from_u64(196); + let __v_24: G = G::from_u64(142); + let __v_25: G = G::from_u64(189); + let __v_26: G = G::from_u64(235); + let __v_27: G = G::from_u64(205); + let __v_28: G = G::from_u64(131); + let __v_29: G = G::from_u64(212); + let __v_30: G = G::from_u64(104); + let __v_31: G = G::from_u64(142); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_175] = [__v_32]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_176: usize = 0; +const IN_176: usize = 0; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); @@ -17951,21 +18354,21 @@ fn aiur_fn_173( 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_173] = [__v_32]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_32]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_174: usize = 0; -const IN_174: usize = 0; -const OUT_174: usize = 1; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_177: usize = 0; +const IN_177: usize = 0; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); @@ -18000,153 +18403,6 @@ fn aiur_fn_174( 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_174] = [__v_32]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_175: usize = 0; -const IN_175: usize = 0; -const OUT_175: usize = 1; -fn aiur_fn_175( - inp: [G; IN_175], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(169); - let __v_1: G = G::from_u64(22); - let __v_2: G = G::from_u64(36); - let __v_3: G = G::from_u64(68); - let __v_4: G = G::from_u64(83); - let __v_5: G = G::from_u64(147); - let __v_6: G = G::from_u64(166); - let __v_7: G = G::from_u64(116); - let __v_8: G = G::from_u64(250); - let __v_9: G = G::from_u64(15); - let __v_10: G = G::from_u64(158); - let __v_11: G = G::from_u64(159); - let __v_12: G = G::from_u64(154); - let __v_13: G = G::from_u64(82); - let __v_14: G = G::from_u64(244); - let __v_15: G = G::from_u64(27); - let __v_16: G = G::from_u64(147); - let __v_17: G = G::from_u64(177); - let __v_18: G = G::from_u64(4); - let __v_19: G = G::from_u64(135); - let __v_20: G = G::from_u64(1); - let __v_21: G = G::from_u64(128); - let __v_22: G = G::from_u64(70); - let __v_23: G = G::from_u64(203); - let __v_24: G = G::from_u64(193); - let __v_25: G = G::from_u64(38); - let __v_26: G = G::from_u64(90); - let __v_27: G = G::from_u64(36); - let __v_28: G = G::from_u64(85); - let __v_29: G = G::from_u64(188); - let __v_30: G = G::from_u64(250); - let __v_31: G = G::from_u64(236); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_175] = [__v_32]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_176: usize = 0; -const IN_176: usize = 0; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(123); - let __v_1: G = G::from_u64(216); - 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_176] = [__v_32]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_177: usize = 0; -const IN_177: usize = 0; -const OUT_177: usize = 1; -fn aiur_fn_177( - inp: [G; IN_177], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(28); - let __v_1: G = G::from_u64(23); - 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_177] = [__v_32]; if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); @@ -18163,38 +18419,38 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(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_0: G = G::from_u64(80); + let __v_1: G = G::from_u64(96); + let __v_2: G = G::from_u64(162); + let __v_3: G = G::from_u64(45); + let __v_4: G = G::from_u64(248); + let __v_5: G = G::from_u64(99); + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(221); + let __v_8: G = G::from_u64(139); + let __v_9: G = G::from_u64(190); + let __v_10: G = G::from_u64(101); + let __v_11: G = G::from_u64(110); + let __v_12: G = G::from_u64(19); + let __v_13: G = G::from_u64(134); + let __v_14: G = G::from_u64(143); + let __v_15: G = G::from_u64(58); + let __v_16: G = G::from_u64(22); + let __v_17: G = G::from_u64(24); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(160); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(128); + let __v_22: G = G::from_u64(184); + let __v_23: G = G::from_u64(203); + let __v_24: G = G::from_u64(176); + let __v_25: G = G::from_u64(7); + let __v_26: G = G::from_u64(89); + let __v_27: G = G::from_u64(207); + let __v_28: G = G::from_u64(253); + let __v_29: G = G::from_u64(49); + let __v_30: G = G::from_u64(128); + let __v_31: G = G::from_u64(13); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_178] = [__v_32]; if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18212,38 +18468,38 @@ fn aiur_fn_179( unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(12); - let __v_1: G = G::from_u64(112); - let __v_2: G = G::from_u64(114); - let __v_3: G = G::from_u64(169); - let __v_4: G = G::from_u64(39); - let __v_5: G = G::from_u64(177); - let __v_6: G = G::from_u64(196); - let __v_7: G = G::from_u64(110); - let __v_8: G = G::from_u64(252); - let __v_9: G = G::from_u64(148); - let __v_10: G = G::from_u64(152); - let __v_11: G = G::from_u64(231); - let __v_12: G = G::from_u64(73); - let __v_13: G = G::from_u64(184); - let __v_14: G = G::from_u64(50); - let __v_15: G = G::from_u64(11); - let __v_16: G = G::from_u64(116); - let __v_17: G = G::from_u64(216); - let __v_18: G = G::from_u64(153); - let __v_19: G = G::from_u64(78); - let __v_20: G = G::from_u64(194); - let __v_21: G = G::from_u64(128); - let __v_22: G = G::from_u64(96); - let __v_23: G = G::from_u64(22); - let __v_24: G = G::from_u64(40); - let __v_25: G = G::from_u64(191); - let __v_26: G = G::from_u64(174); - let __v_27: G = G::from_u64(225); - let __v_28: G = G::from_u64(173); - let __v_29: G = G::from_u64(227); - let __v_30: G = G::from_u64(108); - let __v_31: G = G::from_u64(113); + let __v_0: G = G::from_u64(132); + let __v_1: G = G::from_u64(254); + let __v_2: G = G::from_u64(61); + let __v_3: G = G::from_u64(15); + let __v_4: G = G::from_u64(8); + let __v_5: G = G::from_u64(240); + let __v_6: G = G::from_u64(101); + let __v_7: G = G::from_u64(26); + let __v_8: G = G::from_u64(111); + let __v_9: G = G::from_u64(9); + let __v_10: G = G::from_u64(54); + let __v_11: G = G::from_u64(169); + let __v_12: G = G::from_u64(160); + let __v_13: G = G::from_u64(241); + let __v_14: G = G::from_u64(142); + let __v_15: G = G::from_u64(79); + let __v_16: G = G::from_u64(13); + let __v_17: G = G::from_u64(172); + let __v_18: G = G::from_u64(225); + let __v_19: G = G::from_u64(105); + let __v_20: G = G::from_u64(172); + let __v_21: G = G::from_u64(66); + let __v_22: G = G::from_u64(51); + let __v_23: G = G::from_u64(191); + let __v_24: G = G::from_u64(26); + let __v_25: G = G::from_u64(218); + let __v_26: G = G::from_u64(208); + let __v_27: G = G::from_u64(93); + let __v_28: G = G::from_u64(110); + let __v_29: G = G::from_u64(7); + let __v_30: G = G::from_u64(138); + let __v_31: G = G::from_u64(37); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_179] = [__v_32]; if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18261,38 +18517,38 @@ fn aiur_fn_180( unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(102); - let __v_1: G = G::from_u64(242); - let __v_2: G = G::from_u64(155); - let __v_3: G = G::from_u64(230); - let __v_4: G = G::from_u64(224); - let __v_5: G = G::from_u64(10); - let __v_6: G = G::from_u64(200); - let __v_7: G = G::from_u64(53); - let __v_8: G = G::from_u64(99); - let __v_9: G = G::from_u64(138); - let __v_10: G = G::from_u64(40); - let __v_11: G = G::from_u64(20); - let __v_12: G = G::from_u64(152); - let __v_13: G = G::from_u64(143); - let __v_14: G = G::from_u64(156); - let __v_15: G = G::from_u64(241); - let __v_16: G = G::from_u64(101); - let __v_17: G = G::from_u64(71); - let __v_18: G = G::from_u64(190); - let __v_19: G = G::from_u64(187); - let __v_20: G = G::from_u64(7); - let __v_21: G = G::from_u64(99); - let __v_22: G = G::from_u64(82); - let __v_23: G = G::from_u64(124); - let __v_24: G = G::from_u64(17); - let __v_25: G = G::from_u64(155); - let __v_26: G = G::from_u64(202); - let __v_27: G = G::from_u64(81); - let __v_28: G = G::from_u64(215); - let __v_29: G = G::from_u64(176); - let __v_30: G = G::from_u64(189); - let __v_31: G = G::from_u64(213); + let __v_0: G = G::from_u64(212); + let __v_1: G = G::from_u64(215); + let __v_2: G = G::from_u64(117); + let __v_3: G = G::from_u64(206); + let __v_4: G = G::from_u64(255); + let __v_5: G = G::from_u64(55); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(122); + let __v_8: G = G::from_u64(64); + let __v_9: G = G::from_u64(36); + let __v_10: G = G::from_u64(22); + let __v_11: G = G::from_u64(17); + let __v_12: G = G::from_u64(143); + let __v_13: G = G::from_u64(29); + let __v_14: G = G::from_u64(44); + let __v_15: G = G::from_u64(229); + let __v_16: G = G::from_u64(185); + let __v_17: G = G::from_u64(231); + let __v_18: G = G::from_u64(242); + let __v_19: G = G::from_u64(20); + let __v_20: G = G::from_u64(61); + let __v_21: G = G::from_u64(12); + let __v_22: G = G::from_u64(61); + let __v_23: G = G::from_u64(200); + let __v_24: G = G::from_u64(254); + let __v_25: G = G::from_u64(84); + let __v_26: G = G::from_u64(49); + let __v_27: G = G::from_u64(87); + let __v_28: G = G::from_u64(29); + let __v_29: G = G::from_u64(243); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(12); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_180] = [__v_32]; if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -18300,8 +18556,8 @@ fn aiur_fn_180( }) } -const INPUT_SIZE_181: usize = 1; -const IN_181: usize = 1; +const INPUT_SIZE_181: usize = 0; +const IN_181: usize = 0; const OUT_181: usize = 1; fn aiur_fn_181( inp: [G; IN_181], @@ -18309,71 +18565,218 @@ fn aiur_fn_181( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(32); + let __v_1: G = G::from_u64(117); + let __v_2: G = G::from_u64(189); + let __v_3: G = G::from_u64(165); + let __v_4: G = G::from_u64(69); + let __v_5: G = G::from_u64(123); + let __v_6: G = G::from_u64(41); + let __v_7: G = G::from_u64(155); + let __v_8: G = G::from_u64(39); + let __v_9: G = G::from_u64(36); + let __v_10: G = G::from_u64(103); + let __v_11: G = G::from_u64(112); + let __v_12: G = G::from_u64(200); + let __v_13: G = G::from_u64(65); + let __v_14: G = G::from_u64(98); + let __v_15: G = G::from_u64(115); + let __v_16: G = G::from_u64(104); + let __v_17: G = G::from_u64(107); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(98); + let __v_20: G = G::from_u64(122); + let __v_21: G = G::from_u64(166); + let __v_22: G = G::from_u64(160); + let __v_23: G = G::from_u64(26); + let __v_24: G = G::from_u64(196); + let __v_25: G = G::from_u64(19); + let __v_26: G = G::from_u64(162); + let __v_27: G = G::from_u64(126); + let __v_28: G = G::from_u64(88); + let __v_29: G = G::from_u64(62); + let __v_30: G = G::from_u64(185); + let __v_31: G = G::from_u64(93); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_181] = [__v_32]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_182], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(126); + let __v_1: G = G::from_u64(78); + let __v_2: G = G::from_u64(155); + let __v_3: G = G::from_u64(51); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(150); + let __v_6: G = G::from_u64(167); + let __v_7: G = G::from_u64(211); + let __v_8: G = G::from_u64(252); + let __v_9: G = G::from_u64(225); + let __v_10: G = G::from_u64(116); + let __v_11: G = G::from_u64(93); + let __v_12: G = G::from_u64(251); + let __v_13: G = G::from_u64(95); + let __v_14: G = G::from_u64(190); + let __v_15: G = G::from_u64(235); + let __v_16: G = G::from_u64(147); + let __v_17: G = G::from_u64(143); + let __v_18: G = G::from_u64(200); + let __v_19: G = G::from_u64(136); + let __v_20: G = G::from_u64(42); + let __v_21: G = G::from_u64(130); + let __v_22: G = G::from_u64(190); + let __v_23: G = G::from_u64(225); + let __v_24: G = G::from_u64(87); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(224); + let __v_27: G = G::from_u64(210); + let __v_28: G = G::from_u64(83); + let __v_29: G = G::from_u64(229); + let __v_30: G = G::from_u64(145); + let __v_31: G = G::from_u64(88); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_182] = [__v_32]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_183: usize = 0; +const IN_183: usize = 0; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: [G; IN_183], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_183], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(128); + let __v_1: G = G::from_u64(249); + let __v_2: G = G::from_u64(117); + let __v_3: G = G::from_u64(222); + let __v_4: G = G::from_u64(217); + let __v_5: G = G::from_u64(214); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(112); + let __v_8: G = G::from_u64(149); + let __v_9: G = G::from_u64(233); + let __v_10: G = G::from_u64(219); + let __v_11: G = G::from_u64(46); + let __v_12: G = G::from_u64(209); + let __v_13: G = G::from_u64(207); + let __v_14: G = G::from_u64(166); + let __v_15: G = G::from_u64(245); + let __v_16: G = G::from_u64(195); + let __v_17: G = G::from_u64(94); + let __v_18: G = G::from_u64(175); + let __v_19: G = G::from_u64(229); + let __v_20: G = G::from_u64(197); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(144); + let __v_23: G = G::from_u64(226); + let __v_24: G = G::from_u64(193); + let __v_25: G = G::from_u64(50); + let __v_26: G = G::from_u64(27); + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(197); + let __v_29: G = G::from_u64(102); + let __v_30: G = G::from_u64(78); + let __v_31: G = G::from_u64(108); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_183] = [__v_32]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_184: usize = 1; +const IN_184: usize = 1; +const OUT_184: usize = 1; +fn aiur_fn_184( + inp: [G; IN_184], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_181] = [__v_3]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_3]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_181] = [__v_5]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_5]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_181] = [__v_7]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_7]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_181] = [__v_9]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_9]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_181] = [__v_11]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_11]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_181] = [__v_11]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_11]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18388,15 +18791,15 @@ fn aiur_fn_181( }) } -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_185: usize = 0; +const IN_185: usize = 0; +const OUT_185: usize = 1; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); @@ -18415,21 +18818,21 @@ fn aiur_fn_182( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_16]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_16]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_183: usize = 0; -const IN_183: usize = 0; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_186: usize = 0; +const IN_186: usize = 0; +const OUT_186: usize = 1; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); @@ -18448,72 +18851,72 @@ fn aiur_fn_183( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_16]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_16]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_184: usize = 3; -const IN_184: usize = 3; -const OUT_184: usize = 2; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_187: usize = 3; +const IN_187: usize = 3; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_184] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_184] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_184] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -18525,12 +18928,12 @@ fn aiur_fn_184( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18541,31 +18944,31 @@ fn aiur_fn_184( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_184] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_184] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18582,18 +18985,18 @@ fn aiur_fn_184( }) } -const INPUT_SIZE_185: usize = 1; -const IN_185: usize = 1; -const OUT_185: usize = 2; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_188: usize = 1; +const IN_188: usize = 1; +const OUT_188: usize = 2; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18604,15 +19007,15 @@ fn aiur_fn_185( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18622,17 +19025,17 @@ fn aiur_fn_185( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_185] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18641,8 +19044,8 @@ fn aiur_fn_185( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18653,8 +19056,8 @@ fn aiur_fn_185( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18663,15 +19066,15 @@ fn aiur_fn_185( }) } -const INPUT_SIZE_186: usize = 1; -const IN_186: usize = 1; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_189: usize = 1; +const IN_189: usize = 1; +const OUT_189: usize = 2; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18681,11 +19084,11 @@ fn aiur_fn_186( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -18697,14 +19100,14 @@ fn aiur_fn_186( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_186] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_10, __v_0]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18715,23 +19118,23 @@ fn aiur_fn_186( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_187: usize = 1; -const IN_187: usize = 1; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_190: usize = 1; +const IN_190: usize = 1; +const OUT_190: usize = 2; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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 }; @@ -18744,8 +19147,8 @@ fn aiur_fn_187( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_187] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_0]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18754,8 +19157,8 @@ fn aiur_fn_187( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18766,358 +19169,358 @@ fn aiur_fn_187( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_188: usize = 0; -const IN_188: usize = 0; -const OUT_188: usize = 1; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_191: usize = 0; +const IN_191: usize = 0; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(227); - let __v_1: G = G::from_u64(42); - let __v_2: G = G::from_u64(180); - let __v_3: G = G::from_u64(231); - let __v_4: G = G::from_u64(114); - let __v_5: G = G::from_u64(13); - let __v_6: G = G::from_u64(52); - let __v_7: G = G::from_u64(66); - let __v_8: G = G::from_u64(162); - let __v_9: G = G::from_u64(102); - let __v_10: G = G::from_u64(179); - let __v_11: G = G::from_u64(124); - let __v_12: G = G::from_u64(151); - let __v_13: G = G::from_u64(162); - let __v_14: G = G::from_u64(114); - let __v_15: G = G::from_u64(24); - let __v_16: G = G::from_u64(230); + let __v_0: G = G::from_u64(172); + let __v_1: G = G::from_u64(217); + let __v_2: G = G::from_u64(240); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(247); + let __v_5: G = G::from_u64(232); + let __v_6: G = G::from_u64(197); + let __v_7: G = G::from_u64(58); + let __v_8: G = G::from_u64(70); + let __v_9: G = G::from_u64(185); + let __v_10: G = G::from_u64(23); + let __v_11: G = G::from_u64(89); + let __v_12: G = G::from_u64(53); + let __v_13: G = G::from_u64(131); + let __v_14: G = G::from_u64(102); + let __v_15: G = G::from_u64(250); + let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(130); - let __v_18: G = G::from_u64(57); - let __v_19: G = G::from_u64(49); - let __v_20: G = G::from_u64(131); - let __v_21: G = G::from_u64(17); - let __v_22: G = G::from_u64(248); - let __v_23: G = G::from_u64(228); - let __v_24: G = G::from_u64(176); - let __v_25: G = G::from_u64(70); - let __v_26: G = G::from_u64(166); - let __v_27: G = G::from_u64(189); - let __v_28: G = G::from_u64(222); - let __v_29: G = G::from_u64(82); - let __v_30: G = G::from_u64(3); - let __v_31: G = G::from_u64(116); + let __v_18: G = G::from_u64(64); + let __v_19: G = G::from_u64(176); + let __v_20: G = G::from_u64(182); + let __v_21: G = G::from_u64(204); + let __v_22: G = G::from_u64(9); + let __v_23: G = G::from_u64(32); + let __v_24: G = G::from_u64(93); + let __v_25: G = G::from_u64(222); + let __v_26: G = G::from_u64(52); + let __v_27: G = G::from_u64(163); + let __v_28: G = G::from_u64(53); + let __v_29: G = G::from_u64(68); + let __v_30: G = G::from_u64(103); + let __v_31: G = G::from_u64(141); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_32]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_32]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_189: usize = 0; -const IN_189: usize = 0; -const OUT_189: usize = 1; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_192: usize = 0; +const IN_192: usize = 0; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(59); - let __v_1: G = G::from_u64(51); - let __v_2: G = G::from_u64(76); - let __v_3: G = G::from_u64(148); - let __v_4: G = G::from_u64(221); - let __v_5: G = G::from_u64(86); - let __v_6: G = G::from_u64(216); - let __v_7: G = G::from_u64(11); - let __v_8: G = G::from_u64(235); - let __v_9: G = G::from_u64(78); - let __v_10: G = G::from_u64(255); - let __v_11: G = G::from_u64(93); - let __v_12: G = G::from_u64(130); - let __v_13: G = G::from_u64(95); - let __v_14: G = G::from_u64(103); - let __v_15: G = G::from_u64(246); - let __v_16: G = G::from_u64(241); - let __v_17: G = G::from_u64(172); - let __v_18: G = G::from_u64(78); - let __v_19: G = G::from_u64(20); - let __v_20: G = G::from_u64(4); - let __v_21: G = G::from_u64(3); - let __v_22: G = G::from_u64(105); - let __v_23: G = G::from_u64(158); - let __v_24: G = G::from_u64(61); - let __v_25: G = G::from_u64(175); - let __v_26: G = G::from_u64(245); - let __v_27: G = G::from_u64(42); - let __v_28: G = G::from_u64(0); - let __v_29: G = G::from_u64(189); - let __v_30: G = G::from_u64(191); - let __v_31: G = G::from_u64(110); + let __v_0: G = G::from_u64(87); + let __v_1: G = G::from_u64(33); + let __v_2: G = G::from_u64(202); + let __v_3: G = G::from_u64(42); + let __v_4: G = G::from_u64(207); + let __v_5: G = G::from_u64(44); + let __v_6: G = G::from_u64(105); + let __v_7: G = G::from_u64(148); + let __v_8: G = G::from_u64(119); + let __v_9: G = G::from_u64(21); + let __v_10: G = G::from_u64(9); + let __v_11: G = G::from_u64(51); + let __v_12: G = G::from_u64(47); + let __v_13: G = G::from_u64(177); + let __v_14: G = G::from_u64(133); + let __v_15: G = G::from_u64(247); + let __v_16: G = G::from_u64(131); + let __v_17: G = G::from_u64(244); + let __v_18: G = G::from_u64(66); + let __v_19: G = G::from_u64(174); + let __v_20: G = G::from_u64(252); + let __v_21: G = G::from_u64(228); + let __v_22: G = G::from_u64(23); + let __v_23: G = G::from_u64(210); + let __v_24: G = G::from_u64(134); + let __v_25: G = G::from_u64(62); + let __v_26: G = G::from_u64(45); + let __v_27: G = G::from_u64(20); + let __v_28: G = G::from_u64(142); + let __v_29: G = G::from_u64(220); + let __v_30: G = G::from_u64(219); + let __v_31: G = G::from_u64(138); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_32]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_32]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_190: usize = 0; -const IN_190: usize = 0; -const OUT_190: usize = 1; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_193: usize = 0; +const IN_193: usize = 0; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(103); - let __v_1: G = G::from_u64(244); - let __v_2: G = G::from_u64(116); - let __v_3: G = G::from_u64(184); - let __v_4: G = G::from_u64(195); - let __v_5: G = G::from_u64(48); - let __v_6: G = G::from_u64(43); - let __v_7: G = G::from_u64(4); - let __v_8: G = G::from_u64(65); - let __v_9: G = G::from_u64(127); - let __v_10: G = G::from_u64(114); - let __v_11: G = G::from_u64(31); - let __v_12: G = G::from_u64(243); - let __v_13: G = G::from_u64(232); - let __v_14: G = G::from_u64(140); - let __v_15: G = G::from_u64(230); - let __v_16: G = G::from_u64(241); - let __v_17: G = G::from_u64(106); - let __v_18: G = G::from_u64(125); - let __v_19: G = G::from_u64(252); - let __v_20: G = G::from_u64(179); - let __v_21: G = G::from_u64(186); - let __v_22: G = G::from_u64(233); - let __v_23: G = G::from_u64(147); - let __v_24: G = G::from_u64(104); - let __v_25: G = G::from_u64(8); - let __v_26: G = G::from_u64(93); - let __v_27: G = G::from_u64(28); - let __v_28: G = G::from_u64(94); - let __v_29: G = G::from_u64(135); - let __v_30: G = G::from_u64(43); - let __v_31: G = G::from_u64(164); + let __v_0: G = G::from_u64(199); + let __v_1: G = G::from_u64(25); + let __v_2: G = G::from_u64(42); + let __v_3: G = G::from_u64(197); + let __v_4: G = G::from_u64(7); + let __v_5: G = G::from_u64(214); + let __v_6: G = G::from_u64(124); + let __v_7: G = G::from_u64(60); + let __v_8: G = G::from_u64(62); + let __v_9: G = G::from_u64(30); + let __v_10: G = G::from_u64(185); + let __v_11: G = G::from_u64(6); + let __v_12: G = G::from_u64(51); + let __v_13: G = G::from_u64(133); + let __v_14: G = G::from_u64(138); + let __v_15: G = G::from_u64(231); + let __v_16: G = G::from_u64(183); + let __v_17: G = G::from_u64(203); + let __v_18: G = G::from_u64(200); + let __v_19: G = G::from_u64(14); + let __v_20: G = G::from_u64(57); + let __v_21: G = G::from_u64(136); + let __v_22: G = G::from_u64(49); + let __v_23: G = G::from_u64(38); + let __v_24: G = G::from_u64(24); + let __v_25: G = G::from_u64(199); + let __v_26: G = G::from_u64(236); + let __v_27: G = G::from_u64(9); + let __v_28: G = G::from_u64(180); + let __v_29: G = G::from_u64(131); + let __v_30: G = G::from_u64(176); + let __v_31: G = G::from_u64(74); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_32]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_32]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_191: usize = 0; -const IN_191: usize = 0; -const OUT_191: usize = 1; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_194: usize = 0; +const IN_194: usize = 0; +const OUT_194: usize = 1; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(79); - let __v_1: G = G::from_u64(157); - let __v_2: G = G::from_u64(78); - let __v_3: G = G::from_u64(12); - let __v_4: G = G::from_u64(112); + let __v_0: G = G::from_u64(141); + let __v_1: G = G::from_u64(87); + let __v_2: G = G::from_u64(199); + let __v_3: G = G::from_u64(198); + let __v_4: G = G::from_u64(174); let __v_5: G = G::from_u64(225); - let __v_6: G = G::from_u64(108); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(224); - let __v_9: G = G::from_u64(237); - let __v_10: G = G::from_u64(163); - let __v_11: G = G::from_u64(142); - let __v_12: G = G::from_u64(45); - let __v_13: G = G::from_u64(109); - let __v_14: G = G::from_u64(148); - let __v_15: G = G::from_u64(204); - let __v_16: G = G::from_u64(209); - let __v_17: G = G::from_u64(37); - let __v_18: G = G::from_u64(152); - let __v_19: G = G::from_u64(117); - let __v_20: G = G::from_u64(94); - let __v_21: G = G::from_u64(14); - let __v_22: G = G::from_u64(114); - let __v_23: G = G::from_u64(0); - let __v_24: G = G::from_u64(169); - let __v_25: G = G::from_u64(35); - let __v_26: G = G::from_u64(157); - let __v_27: G = G::from_u64(169); - let __v_28: G = G::from_u64(43); - let __v_29: G = G::from_u64(144); - let __v_30: G = G::from_u64(87); - let __v_31: G = G::from_u64(204); + let __v_6: G = G::from_u64(186); + let __v_7: G = G::from_u64(81); + let __v_8: G = G::from_u64(13); + let __v_9: G = G::from_u64(50); + let __v_10: G = G::from_u64(8); + let __v_11: G = G::from_u64(221); + let __v_12: G = G::from_u64(196); + let __v_13: G = G::from_u64(176); + let __v_14: G = G::from_u64(138); + let __v_15: G = G::from_u64(131); + let __v_16: G = G::from_u64(180); + let __v_17: G = G::from_u64(67); + let __v_18: G = G::from_u64(25); + let __v_19: G = G::from_u64(246); + let __v_20: G = G::from_u64(175); + let __v_21: G = G::from_u64(142); + let __v_22: G = G::from_u64(224); + let __v_23: G = G::from_u64(155); + let __v_24: G = G::from_u64(57); + let __v_25: G = G::from_u64(64); + let __v_26: G = G::from_u64(208); + let __v_27: G = G::from_u64(221); + let __v_28: G = G::from_u64(237); + let __v_29: G = G::from_u64(206); + let __v_30: G = G::from_u64(30); + let __v_31: G = G::from_u64(182); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_32]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_32]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 0; -const IN_192: usize = 0; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_195: usize = 0; +const IN_195: usize = 0; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(197); - let __v_1: G = G::from_u64(247); - 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_0: G = G::from_u64(209); + let __v_1: G = G::from_u64(16); + let __v_2: G = G::from_u64(124); + let __v_3: G = G::from_u64(153); + let __v_4: G = G::from_u64(173); + let __v_5: G = G::from_u64(158); + let __v_6: G = G::from_u64(188); + let __v_7: G = G::from_u64(181); + let __v_8: G = G::from_u64(2); + let __v_9: G = G::from_u64(141); + let __v_10: G = G::from_u64(154); + let __v_11: G = G::from_u64(234); + let __v_12: G = G::from_u64(13); + let __v_13: G = G::from_u64(165); + let __v_14: G = G::from_u64(33); + let __v_15: G = G::from_u64(237); + let __v_16: G = G::from_u64(92); + let __v_17: G = G::from_u64(18); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(30); + let __v_20: G = G::from_u64(162); + let __v_21: G = G::from_u64(236); + let __v_22: G = G::from_u64(222); + let __v_23: G = G::from_u64(175); + let __v_24: G = G::from_u64(99); + let __v_25: G = G::from_u64(123); + let __v_26: G = G::from_u64(180); + let __v_27: G = G::from_u64(161); + let __v_28: G = G::from_u64(77); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(126); + let __v_31: G = G::from_u64(68); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_32]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_32]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_193: usize = 0; -const IN_193: usize = 0; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_196: usize = 0; +const IN_196: usize = 0; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(202); - let __v_1: G = G::from_u64(202); - 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_0: G = G::from_u64(198); + let __v_1: G = G::from_u64(157); + let __v_2: G = G::from_u64(244); + let __v_3: G = G::from_u64(131); + let __v_4: G = G::from_u64(62); 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_6: G = G::from_u64(206); + let __v_7: G = G::from_u64(118); + let __v_8: G = G::from_u64(189); + let __v_9: G = G::from_u64(176); + let __v_10: G = G::from_u64(210); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(89); + let __v_13: G = G::from_u64(225); + let __v_14: G = G::from_u64(250); + let __v_15: G = G::from_u64(198); + let __v_16: G = G::from_u64(82); + let __v_17: G = G::from_u64(216); + let __v_18: G = G::from_u64(137); + let __v_19: G = G::from_u64(25); + let __v_20: G = G::from_u64(118); + let __v_21: G = G::from_u64(140); + let __v_22: G = G::from_u64(49); + let __v_23: G = G::from_u64(44); + let __v_24: G = G::from_u64(102); + let __v_25: G = G::from_u64(17); + let __v_26: G = G::from_u64(220); + let __v_27: G = G::from_u64(6); + let __v_28: G = G::from_u64(13); + let __v_29: G = G::from_u64(161); + let __v_30: G = G::from_u64(111); + let __v_31: G = G::from_u64(4); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_193] = [__v_32]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_32]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 1; -const IN_194: usize = 1; -const OUT_194: usize = 1; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_194] = [__v_3]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_3]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_194] = [__v_5]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_5]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_7]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_7]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19128,61 +19531,61 @@ fn aiur_fn_194( }) } -const INPUT_SIZE_195: usize = 1; -const IN_195: usize = 1; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_7]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_7]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_7]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_7]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_196: usize = 2; -const IN_196: usize = 2; -const OUT_196: usize = 2; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_199: usize = 2; +const IN_199: usize = 2; +const OUT_199: usize = 2; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -19192,12 +19595,12 @@ fn aiur_fn_196( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19206,12 +19609,12 @@ fn aiur_fn_196( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19220,8 +19623,8 @@ fn aiur_fn_196( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -19238,15 +19641,15 @@ fn aiur_fn_196( let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_196] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_23, __v_25]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19266,18 +19669,18 @@ fn aiur_fn_196( }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -const OUT_197: usize = 2; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19288,21 +19691,21 @@ fn aiur_fn_197( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19312,12 +19715,12 @@ fn aiur_fn_197( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19327,20 +19730,20 @@ fn aiur_fn_197( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_197] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19357,18 +19760,18 @@ fn aiur_fn_197( }) } -const INPUT_SIZE_198: usize = 1; -const IN_198: usize = 1; -const OUT_198: usize = 2; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19379,15 +19782,15 @@ fn aiur_fn_198( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19397,7 +19800,7 @@ fn aiur_fn_198( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -19408,12 +19811,12 @@ fn aiur_fn_198( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19424,15 +19827,15 @@ fn aiur_fn_198( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19442,7 +19845,7 @@ fn aiur_fn_198( let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -19453,12 +19856,12 @@ fn aiur_fn_198( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_27, __v_31]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19469,19 +19872,19 @@ fn aiur_fn_198( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_30, __v_34]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); @@ -19492,11 +19895,11 @@ fn aiur_fn_198( let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_198] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19509,8 +19912,8 @@ fn aiur_fn_198( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_25, __v_29]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19525,8 +19928,8 @@ fn aiur_fn_198( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19535,18 +19938,18 @@ fn aiur_fn_198( }) } -const INPUT_SIZE_199: usize = 1; -const IN_199: usize = 1; -const OUT_199: usize = 3; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_202: usize = 1; +const IN_202: usize = 1; +const OUT_202: usize = 3; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19556,13 +19959,13 @@ fn aiur_fn_199( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19570,13 +19973,13 @@ fn aiur_fn_199( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_199] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19589,8 +19992,8 @@ fn aiur_fn_199( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19605,8 +20008,8 @@ fn aiur_fn_199( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19621,34 +20024,34 @@ fn aiur_fn_199( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_200: usize = 3; -const IN_200: usize = 3; -const OUT_200: usize = 2; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_203: usize = 3; +const IN_203: usize = 3; +const OUT_203: usize = 2; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19659,20 +20062,20 @@ fn aiur_fn_200( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -19682,16 +20085,16 @@ fn aiur_fn_200( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_200] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19702,33 +20105,33 @@ fn aiur_fn_200( } }, _ => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_200] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_200] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19737,8 +20140,8 @@ fn aiur_fn_200( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19749,19 +20152,19 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 2; -const IN_201: usize = 2; -const OUT_201: usize = 1; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_204: usize = 2; +const IN_204: usize = 2; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __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]; @@ -19769,8 +20172,8 @@ fn aiur_fn_201( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_201] = [__v_2]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -19780,8 +20183,8 @@ fn aiur_fn_201( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_201] = [__v_2]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -19791,14 +20194,14 @@ fn aiur_fn_201( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_201] = [__v_2]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -19806,8 +20209,8 @@ fn aiur_fn_201( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_19]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_19]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19827,173 +20230,26 @@ fn aiur_fn_201( }) } -const INPUT_SIZE_202: usize = 2; -const IN_202: usize = 2; -const OUT_202: usize = 1; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_205: usize = 2; +const IN_205: usize = 2; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_202] = [__v_5]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_203: usize = 0; -const IN_203: usize = 0; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(81); - let __v_1: G = G::from_u64(134); - let __v_2: G = G::from_u64(217); - let __v_3: G = G::from_u64(30); - let __v_4: G = G::from_u64(248); - let __v_5: G = G::from_u64(137); - let __v_6: G = G::from_u64(46); - let __v_7: G = G::from_u64(72); - let __v_8: G = G::from_u64(235); - let __v_9: G = G::from_u64(2); - let __v_10: G = G::from_u64(145); - let __v_11: G = G::from_u64(139); - let __v_12: G = G::from_u64(9); - let __v_13: G = G::from_u64(38); - let __v_14: G = G::from_u64(233); - let __v_15: G = G::from_u64(118); - let __v_16: G = G::from_u64(124); - let __v_17: G = G::from_u64(109); - let __v_18: G = G::from_u64(75); - let __v_19: G = G::from_u64(155); - let __v_20: G = G::from_u64(8); - let __v_21: G = G::from_u64(20); - let __v_22: G = G::from_u64(6); - let __v_23: G = G::from_u64(74); - let __v_24: G = G::from_u64(68); - let __v_25: G = G::from_u64(154); - let __v_26: G = G::from_u64(90); - let __v_27: G = G::from_u64(254); - let __v_28: G = G::from_u64(138); - let __v_29: G = G::from_u64(158); - let __v_30: G = G::from_u64(90); - let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_32]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_204: usize = 0; -const IN_204: usize = 0; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(255); - let __v_1: G = G::from_u64(69); - let __v_2: G = G::from_u64(149); - let __v_3: G = G::from_u64(84); - let __v_4: G = G::from_u64(223); - let __v_5: G = G::from_u64(220); - let __v_6: G = G::from_u64(52); - let __v_7: G = G::from_u64(209); - let __v_8: G = G::from_u64(89); - let __v_9: G = G::from_u64(2); - let __v_10: G = G::from_u64(112); - let __v_11: G = G::from_u64(56); - let __v_12: G = G::from_u64(23); - let __v_13: G = G::from_u64(69); - let __v_14: G = G::from_u64(113); - let __v_15: G = G::from_u64(183); - let __v_16: G = G::from_u64(112); - let __v_17: G = G::from_u64(70); - let __v_18: G = G::from_u64(77); - let __v_19: G = G::from_u64(82); - let __v_20: G = G::from_u64(131); - let __v_21: G = G::from_u64(76); - let __v_22: G = G::from_u64(29); - let __v_23: G = G::from_u64(188); - let __v_24: G = G::from_u64(100); - let __v_25: G = G::from_u64(54); - let __v_26: G = G::from_u64(70); - let __v_27: G = G::from_u64(127); - let __v_28: G = G::from_u64(168); - let __v_29: G = G::from_u64(29); - let __v_30: G = G::from_u64(3); - let __v_31: G = G::from_u64(158); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_204] = [__v_32]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_205: usize = 0; -const IN_205: usize = 0; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(15); - let __v_1: G = G::from_u64(2); - let __v_2: G = G::from_u64(80); - let __v_3: G = G::from_u64(215); - let __v_4: G = G::from_u64(113); - let __v_5: G = G::from_u64(55); - let __v_6: G = G::from_u64(4); - let __v_7: G = G::from_u64(67); - let __v_8: G = G::from_u64(144); - let __v_9: G = G::from_u64(115); - let __v_10: G = G::from_u64(186); - let __v_11: G = G::from_u64(189); - let __v_12: G = G::from_u64(81); - let __v_13: G = G::from_u64(27); - let __v_14: G = G::from_u64(119); - let __v_15: G = G::from_u64(169); - let __v_16: G = G::from_u64(238); - let __v_17: G = G::from_u64(234); - let __v_18: G = G::from_u64(229); - let __v_19: G = G::from_u64(173); - let __v_20: G = G::from_u64(189); - let __v_21: G = G::from_u64(80); - let __v_22: G = G::from_u64(255); - let __v_23: G = G::from_u64(87); - let __v_24: G = G::from_u64(77); - let __v_25: G = G::from_u64(128); - let __v_26: G = G::from_u64(31); - let __v_27: G = G::from_u64(251); - let __v_28: G = G::from_u64(85); - let __v_29: G = G::from_u64(129); - let __v_30: G = G::from_u64(40); - let __v_31: G = G::from_u64(217); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_205] = [__v_32]; + let __ret: [G; OUT_205] = [__v_5]; if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -20009,38 +20265,38 @@ fn aiur_fn_206( unconstrained: bool, ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(9); - let __v_1: G = G::from_u64(238); - let __v_2: G = G::from_u64(180); - let __v_3: G = G::from_u64(22); - let __v_4: G = G::from_u64(200); - let __v_5: G = G::from_u64(64); - let __v_6: G = G::from_u64(118); - let __v_7: G = G::from_u64(102); - let __v_8: G = G::from_u64(100); - let __v_9: G = G::from_u64(87); - let __v_10: G = G::from_u64(65); - let __v_11: G = G::from_u64(127); - let __v_12: G = G::from_u64(75); - let __v_13: G = G::from_u64(124); - let __v_14: G = G::from_u64(227); - let __v_15: G = G::from_u64(209); - let __v_16: G = G::from_u64(191); - let __v_17: G = G::from_u64(52); - let __v_18: G = G::from_u64(151); - let __v_19: G = G::from_u64(125); - let __v_20: G = G::from_u64(63); - let __v_21: G = G::from_u64(86); - let __v_22: G = G::from_u64(221); - let __v_23: G = G::from_u64(37); - let __v_24: G = G::from_u64(98); - let __v_25: G = G::from_u64(192); - let __v_26: G = G::from_u64(1); - let __v_27: G = G::from_u64(74); - let __v_28: G = G::from_u64(81); - let __v_29: G = G::from_u64(203); - let __v_30: G = G::from_u64(141); - let __v_31: G = G::from_u64(52); + let __v_0: G = G::from_u64(177); + let __v_1: G = G::from_u64(246); + let __v_2: G = G::from_u64(240); + let __v_3: G = G::from_u64(75); + let __v_4: G = G::from_u64(222); + let __v_5: G = G::from_u64(61); + let __v_6: G = G::from_u64(129); + let __v_7: G = G::from_u64(249); + let __v_8: G = G::from_u64(16); + let __v_9: G = G::from_u64(46); + let __v_10: G = G::from_u64(166); + let __v_11: G = G::from_u64(183); + let __v_12: G = G::from_u64(210); + let __v_13: G = G::from_u64(201); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(35); + let __v_16: G = G::from_u64(109); + let __v_17: G = G::from_u64(114); + let __v_18: G = G::from_u64(177); + let __v_19: G = G::from_u64(126); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(18); + let __v_22: G = G::from_u64(85); + let __v_23: G = G::from_u64(35); + let __v_24: G = G::from_u64(197); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(226); + let __v_27: G = G::from_u64(97); + let __v_28: G = G::from_u64(175); + let __v_29: G = G::from_u64(199); + let __v_30: G = G::from_u64(17); + let __v_31: G = G::from_u64(5); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_206] = [__v_32]; if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20058,38 +20314,38 @@ fn aiur_fn_207( unconstrained: bool, ) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(37); - let __v_1: G = G::from_u64(138); - 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_0: G = G::from_u64(182); + let __v_1: G = G::from_u64(236); + let __v_2: G = G::from_u64(45); + let __v_3: G = G::from_u64(68); + let __v_4: G = G::from_u64(63); + let __v_5: G = G::from_u64(62); + let __v_6: G = G::from_u64(230); + let __v_7: G = G::from_u64(29); + let __v_8: G = G::from_u64(228); + let __v_9: G = G::from_u64(90); + let __v_10: G = G::from_u64(216); + let __v_11: G = G::from_u64(89); + let __v_12: G = G::from_u64(184); + let __v_13: G = G::from_u64(204); + let __v_14: G = G::from_u64(65); + let __v_15: G = G::from_u64(168); + let __v_16: G = G::from_u64(150); + let __v_17: G = G::from_u64(216); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(164); + let __v_20: G = G::from_u64(155); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(152); + let __v_23: G = G::from_u64(131); + let __v_24: G = G::from_u64(252); + let __v_25: G = G::from_u64(52); + let __v_26: G = G::from_u64(196); + let __v_27: G = G::from_u64(39); + let __v_28: G = G::from_u64(219); + let __v_29: G = G::from_u64(223); + let __v_30: G = G::from_u64(113); + let __v_31: G = G::from_u64(248); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_207] = [__v_32]; if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20107,38 +20363,38 @@ fn aiur_fn_208( unconstrained: bool, ) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(119); - let __v_1: G = G::from_u64(213); - 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_0: G = G::from_u64(213); + let __v_1: G = G::from_u64(77); + let __v_2: G = G::from_u64(183); + let __v_3: G = G::from_u64(31); + let __v_4: G = G::from_u64(238); + let __v_5: G = G::from_u64(85); + let __v_6: G = G::from_u64(49); + let __v_7: G = G::from_u64(26); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(238); + let __v_10: G = G::from_u64(173); + let __v_11: G = G::from_u64(116); + let __v_12: G = G::from_u64(118); + let __v_13: G = G::from_u64(142); + let __v_14: G = G::from_u64(110); + let __v_15: G = G::from_u64(149); + let __v_16: G = G::from_u64(34); + let __v_17: G = G::from_u64(98); + let __v_18: G = G::from_u64(194); + let __v_19: G = G::from_u64(154); + let __v_20: G = G::from_u64(189); + let __v_21: G = G::from_u64(36); + let __v_22: G = G::from_u64(185); + let __v_23: G = G::from_u64(49); + let __v_24: G = G::from_u64(159); + let __v_25: G = G::from_u64(166); + let __v_26: G = G::from_u64(133); + let __v_27: G = G::from_u64(148); + let __v_28: G = G::from_u64(129); + let __v_29: G = G::from_u64(221); + let __v_30: G = G::from_u64(68); + let __v_31: G = G::from_u64(184); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_208] = [__v_32]; if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20156,38 +20412,38 @@ fn aiur_fn_209( unconstrained: bool, ) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(32); - let __v_1: G = G::from_u64(59); - let __v_2: G = G::from_u64(118); - let __v_3: G = G::from_u64(197); - let __v_4: G = G::from_u64(180); - let __v_5: G = G::from_u64(245); - let __v_6: G = G::from_u64(202); - let __v_7: G = G::from_u64(6); - let __v_8: G = G::from_u64(21); - let __v_9: G = G::from_u64(99); - let __v_10: G = G::from_u64(49); - let __v_11: G = G::from_u64(64); - let __v_12: G = G::from_u64(87); - let __v_13: G = G::from_u64(169); - let __v_14: G = G::from_u64(67); - let __v_15: G = G::from_u64(188); - let __v_16: G = G::from_u64(67); - let __v_17: G = G::from_u64(128); - let __v_18: G = G::from_u64(136); - let __v_19: G = G::from_u64(94); - let __v_20: G = G::from_u64(115); - let __v_21: G = G::from_u64(208); - let __v_22: G = G::from_u64(239); - let __v_23: G = G::from_u64(175); - let __v_24: G = G::from_u64(20); - let __v_25: G = G::from_u64(100); - let __v_26: G = G::from_u64(69); - let __v_27: G = G::from_u64(152); - let __v_28: G = G::from_u64(194); - let __v_29: G = G::from_u64(250); - let __v_30: G = G::from_u64(110); - let __v_31: G = G::from_u64(238); + let __v_0: G = G::from_u64(41); + let __v_1: G = G::from_u64(86); + let __v_2: G = G::from_u64(61); + let __v_3: G = G::from_u64(162); + let __v_4: G = G::from_u64(113); + let __v_5: G = G::from_u64(194); + let __v_6: G = G::from_u64(63); + let __v_7: G = G::from_u64(102); + let __v_8: G = G::from_u64(178); + let __v_9: G = G::from_u64(125); + let __v_10: G = G::from_u64(5); + let __v_11: G = G::from_u64(249); + let __v_12: G = G::from_u64(36); + let __v_13: G = G::from_u64(251); + let __v_14: G = G::from_u64(6); + let __v_15: G = G::from_u64(18); + let __v_16: G = G::from_u64(39); + let __v_17: G = G::from_u64(45); + let __v_18: G = G::from_u64(207); + let __v_19: G = G::from_u64(186); + let __v_20: G = G::from_u64(107); + let __v_21: G = G::from_u64(16); + let __v_22: G = G::from_u64(131); + let __v_23: G = G::from_u64(179); + let __v_24: G = G::from_u64(72); + let __v_25: G = G::from_u64(115); + let __v_26: G = G::from_u64(62); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(249); + let __v_29: G = G::from_u64(179); + let __v_30: G = G::from_u64(107); + let __v_31: G = G::from_u64(42); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_209] = [__v_32]; if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20205,38 +20461,38 @@ fn aiur_fn_210( unconstrained: bool, ) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(84); - let __v_1: G = G::from_u64(139); - let __v_2: G = G::from_u64(191); - let __v_3: G = G::from_u64(34); - let __v_4: G = G::from_u64(186); - let __v_5: G = G::from_u64(48); - let __v_6: G = G::from_u64(95); - let __v_7: G = G::from_u64(142); - let __v_8: G = G::from_u64(54); - let __v_9: G = G::from_u64(62); - let __v_10: G = G::from_u64(223); - let __v_11: G = G::from_u64(153); - let __v_12: G = G::from_u64(7); - let __v_13: G = G::from_u64(208); - let __v_14: G = G::from_u64(194); - let __v_15: G = G::from_u64(196); - let __v_16: G = G::from_u64(84); - let __v_17: G = G::from_u64(173); - let __v_18: G = G::from_u64(212); - let __v_19: G = G::from_u64(22); - let __v_20: G = G::from_u64(221); - let __v_21: G = G::from_u64(191); - let __v_22: G = G::from_u64(37); - let __v_23: G = G::from_u64(179); - let __v_24: G = G::from_u64(140); - let __v_25: G = G::from_u64(118); - let __v_26: G = G::from_u64(208); - let __v_27: G = G::from_u64(6); - let __v_28: G = G::from_u64(58); - let __v_29: G = G::from_u64(210); - let __v_30: G = G::from_u64(29); - let __v_31: G = G::from_u64(101); + let __v_0: G = G::from_u64(60); + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(73); + let __v_3: G = G::from_u64(195); + let __v_4: G = G::from_u64(67); + let __v_5: G = G::from_u64(41); + let __v_6: G = G::from_u64(105); + let __v_7: G = G::from_u64(238); + let __v_8: G = G::from_u64(93); + let __v_9: G = G::from_u64(147); + let __v_10: G = G::from_u64(84); + let __v_11: G = G::from_u64(200); + let __v_12: G = G::from_u64(210); + let __v_13: G = G::from_u64(216); + let __v_14: G = G::from_u64(156); + let __v_15: G = G::from_u64(238); + let __v_16: G = G::from_u64(196); + let __v_17: G = G::from_u64(167); + let __v_18: G = G::from_u64(151); + let __v_19: G = G::from_u64(17); + let __v_20: G = G::from_u64(248); + let __v_21: G = G::from_u64(222); + let __v_22: G = G::from_u64(200); + let __v_23: G = G::from_u64(113); + let __v_24: G = G::from_u64(8); + let __v_25: G = G::from_u64(121); + let __v_26: G = G::from_u64(161); + let __v_27: G = G::from_u64(42); + let __v_28: G = G::from_u64(18); + let __v_29: G = G::from_u64(183); + let __v_30: G = G::from_u64(44); + let __v_31: G = G::from_u64(66); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_210] = [__v_32]; if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20254,38 +20510,38 @@ fn aiur_fn_211( unconstrained: bool, ) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(239); - let __v_1: G = G::from_u64(78); - let __v_2: G = G::from_u64(116); - let __v_3: G = G::from_u64(228); - let __v_4: G = G::from_u64(78); - let __v_5: G = G::from_u64(59); - let __v_6: G = G::from_u64(185); - let __v_7: G = G::from_u64(250); - let __v_8: G = G::from_u64(94); - let __v_9: G = G::from_u64(84); - let __v_10: G = G::from_u64(136); - let __v_11: G = G::from_u64(164); - let __v_12: G = G::from_u64(108); - let __v_13: G = G::from_u64(91); - let __v_14: G = G::from_u64(77); - let __v_15: G = G::from_u64(97); - let __v_16: G = G::from_u64(251); - let __v_17: G = G::from_u64(253); - let __v_18: G = G::from_u64(112); - let __v_19: G = G::from_u64(30); - let __v_20: G = G::from_u64(54); - let __v_21: G = G::from_u64(121); - let __v_22: G = G::from_u64(197); - let __v_23: G = G::from_u64(191); - let __v_24: G = G::from_u64(180); - let __v_25: G = G::from_u64(21); - let __v_26: G = G::from_u64(76); - let __v_27: G = G::from_u64(135); - let __v_28: G = G::from_u64(71); - let __v_29: G = G::from_u64(206); - let __v_30: G = G::from_u64(253); - let __v_31: G = G::from_u64(201); + let __v_0: G = G::from_u64(209); + let __v_1: G = G::from_u64(224); + let __v_2: G = G::from_u64(128); + let __v_3: G = G::from_u64(44); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(188); + let __v_6: G = G::from_u64(218); + let __v_7: G = G::from_u64(20); + let __v_8: G = G::from_u64(6); + let __v_9: G = G::from_u64(30); + let __v_10: G = G::from_u64(32); + let __v_11: G = G::from_u64(18); + let __v_12: G = G::from_u64(241); + let __v_13: G = G::from_u64(46); + let __v_14: G = G::from_u64(115); + let __v_15: G = G::from_u64(194); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(74); + let __v_18: G = G::from_u64(103); + let __v_19: G = G::from_u64(17); + let __v_20: G = G::from_u64(55); + let __v_21: G = G::from_u64(152); + let __v_22: G = G::from_u64(79); + let __v_23: G = G::from_u64(142); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(103); + let __v_26: G = G::from_u64(68); + let __v_27: G = G::from_u64(234); + let __v_28: G = G::from_u64(4); + let __v_29: G = G::from_u64(209); + let __v_30: G = G::from_u64(136); + let __v_31: G = G::from_u64(196); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_211] = [__v_32]; if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20303,38 +20559,38 @@ fn aiur_fn_212( unconstrained: bool, ) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(135); - let __v_1: G = G::from_u64(9); - let __v_2: G = G::from_u64(245); - let __v_3: G = G::from_u64(112); - let __v_4: G = G::from_u64(168); + let __v_0: G = G::from_u64(213); + let __v_1: G = G::from_u64(84); + let __v_2: G = G::from_u64(41); + let __v_3: G = G::from_u64(114); + let __v_4: G = G::from_u64(90); let __v_5: G = G::from_u64(25); - let __v_6: G = G::from_u64(50); - let __v_7: G = G::from_u64(82); - let __v_8: G = G::from_u64(24); - let __v_9: G = G::from_u64(42); - let __v_10: G = G::from_u64(158); - let __v_11: G = G::from_u64(205); - let __v_12: G = G::from_u64(113); - let __v_13: G = G::from_u64(63); - let __v_14: G = G::from_u64(137); - let __v_15: G = G::from_u64(14); - let __v_16: G = G::from_u64(117); - let __v_17: G = G::from_u64(211); - let __v_18: G = G::from_u64(191); - let __v_19: G = G::from_u64(181); - let __v_20: G = G::from_u64(162); - let __v_21: G = G::from_u64(127); - let __v_22: G = G::from_u64(91); - let __v_23: G = G::from_u64(145); - let __v_24: G = G::from_u64(129); - let __v_25: G = G::from_u64(204); - let __v_26: G = G::from_u64(171); - let __v_27: G = G::from_u64(224); - let __v_28: G = G::from_u64(101); - let __v_29: G = G::from_u64(74); - let __v_30: G = G::from_u64(12); - let __v_31: G = G::from_u64(41); + let __v_6: G = G::from_u64(193); + let __v_7: G = G::from_u64(131); + let __v_8: G = G::from_u64(123); + let __v_9: G = G::from_u64(52); + let __v_10: G = G::from_u64(98); + let __v_11: G = G::from_u64(79); + let __v_12: G = G::from_u64(179); + let __v_13: G = G::from_u64(87); + let __v_14: G = G::from_u64(132); + let __v_15: G = G::from_u64(185); + let __v_16: G = G::from_u64(27); + let __v_17: G = G::from_u64(200); + let __v_18: G = G::from_u64(176); + let __v_19: G = G::from_u64(226); + let __v_20: G = G::from_u64(215); + let __v_21: G = G::from_u64(159); + let __v_22: G = G::from_u64(152); + let __v_23: G = G::from_u64(179); + let __v_24: G = G::from_u64(194); + let __v_25: G = G::from_u64(150); + let __v_26: G = G::from_u64(49); + let __v_27: G = G::from_u64(127); + let __v_28: G = G::from_u64(182); + let __v_29: G = G::from_u64(197); + let __v_30: G = G::from_u64(199); + let __v_31: G = G::from_u64(137); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_212] = [__v_32]; if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20352,38 +20608,38 @@ fn aiur_fn_213( unconstrained: bool, ) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(13); - let __v_1: G = G::from_u64(35); - let __v_2: G = G::from_u64(99); - let __v_3: G = G::from_u64(214); - let __v_4: G = G::from_u64(3); - let __v_5: G = G::from_u64(92); - let __v_6: G = G::from_u64(199); - let __v_7: G = G::from_u64(192); - let __v_8: G = G::from_u64(51); - let __v_9: G = G::from_u64(31); - let __v_10: G = G::from_u64(255); - let __v_11: G = G::from_u64(92); - let __v_12: G = G::from_u64(161); - let __v_13: G = G::from_u64(222); - let __v_14: G = G::from_u64(123); - let __v_15: G = G::from_u64(64); - let __v_16: G = G::from_u64(145); - let __v_17: G = G::from_u64(37); - let __v_18: G = G::from_u64(27); - let __v_19: G = G::from_u64(80); - let __v_20: G = G::from_u64(77); - let __v_21: G = G::from_u64(68); - let __v_22: G = G::from_u64(238); - let __v_23: G = G::from_u64(178); - let __v_24: G = G::from_u64(133); - let __v_25: G = G::from_u64(9); - let __v_26: G = G::from_u64(147); - let __v_27: G = G::from_u64(189); - let __v_28: G = G::from_u64(13); - let __v_29: G = G::from_u64(221); - let __v_30: G = G::from_u64(226); - let __v_31: G = G::from_u64(34); + let __v_0: G = G::from_u64(63); + let __v_1: G = G::from_u64(146); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(106); + let __v_4: G = G::from_u64(20); + let __v_5: G = G::from_u64(81); + let __v_6: G = G::from_u64(253); + let __v_7: G = G::from_u64(102); + let __v_8: G = G::from_u64(33); + let __v_9: G = G::from_u64(90); + let __v_10: G = G::from_u64(174); + let __v_11: G = G::from_u64(156); + let __v_12: G = G::from_u64(247); + let __v_13: G = G::from_u64(137); + let __v_14: G = G::from_u64(206); + let __v_15: G = G::from_u64(56); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(199); + let __v_18: G = G::from_u64(63); + let __v_19: G = G::from_u64(221); + let __v_20: G = G::from_u64(85); + let __v_21: G = G::from_u64(144); + let __v_22: G = G::from_u64(157); + let __v_23: G = G::from_u64(69); + let __v_24: G = G::from_u64(79); + let __v_25: G = G::from_u64(97); + let __v_26: G = G::from_u64(37); + let __v_27: G = G::from_u64(150); + let __v_28: G = G::from_u64(52); + let __v_29: G = G::from_u64(217); + let __v_30: G = G::from_u64(11); + let __v_31: G = G::from_u64(107); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_213] = [__v_32]; if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20401,38 +20657,38 @@ fn aiur_fn_214( unconstrained: bool, ) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(20); - let __v_1: G = G::from_u64(207); - let __v_2: G = G::from_u64(81); - let __v_3: G = G::from_u64(155); - let __v_4: G = G::from_u64(5); - let __v_5: G = G::from_u64(195); - let __v_6: G = G::from_u64(3); - let __v_7: G = G::from_u64(132); - let __v_8: G = G::from_u64(253); - let __v_9: G = G::from_u64(76); - let __v_10: G = G::from_u64(178); - let __v_11: G = G::from_u64(226); - let __v_12: G = G::from_u64(113); - let __v_13: G = G::from_u64(176); - let __v_14: G = G::from_u64(137); - let __v_15: G = G::from_u64(111); - let __v_16: G = G::from_u64(226); - let __v_17: G = G::from_u64(62); - let __v_18: G = G::from_u64(116); - let __v_19: G = G::from_u64(201); - let __v_20: G = G::from_u64(149); - let __v_21: G = G::from_u64(1); - let __v_22: G = G::from_u64(13); - let __v_23: G = G::from_u64(66); - let __v_24: G = G::from_u64(235); - let __v_25: G = G::from_u64(31); - let __v_26: G = G::from_u64(252); - let __v_27: G = G::from_u64(225); - let __v_28: G = G::from_u64(73); - let __v_29: G = G::from_u64(39); - let __v_30: G = G::from_u64(229); - let __v_31: G = G::from_u64(107); + let __v_0: G = G::from_u64(162); + let __v_1: G = G::from_u64(163); + let __v_2: G = G::from_u64(16); + let __v_3: G = G::from_u64(19); + let __v_4: G = G::from_u64(61); + let __v_5: G = G::from_u64(23); + let __v_6: G = G::from_u64(55); + let __v_7: G = G::from_u64(26); + let __v_8: G = G::from_u64(246); + let __v_9: G = G::from_u64(124); + let __v_10: G = G::from_u64(217); + let __v_11: G = G::from_u64(29); + let __v_12: G = G::from_u64(39); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(175); + let __v_15: G = G::from_u64(115); + let __v_16: G = G::from_u64(95); + let __v_17: G = G::from_u64(168); + let __v_18: G = G::from_u64(203); + let __v_19: G = G::from_u64(129); + let __v_20: G = G::from_u64(12); + let __v_21: G = G::from_u64(57); + let __v_22: G = G::from_u64(170); + let __v_23: G = G::from_u64(168); + let __v_24: G = G::from_u64(36); + let __v_25: G = G::from_u64(164); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(198); + let __v_28: G = G::from_u64(82); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(223); + let __v_31: G = G::from_u64(102); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_214] = [__v_32]; if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20450,38 +20706,38 @@ fn aiur_fn_215( unconstrained: bool, ) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(253); - let __v_1: G = G::from_u64(83); - let __v_2: G = G::from_u64(232); - let __v_3: G = G::from_u64(220); - let __v_4: G = G::from_u64(232); - let __v_5: G = G::from_u64(45); - let __v_6: G = G::from_u64(86); - let __v_7: G = G::from_u64(139); - let __v_8: G = G::from_u64(86); - let __v_9: G = G::from_u64(233); - let __v_10: G = G::from_u64(177); - let __v_11: G = G::from_u64(108); - let __v_12: G = G::from_u64(57); - let __v_13: G = G::from_u64(11); - let __v_14: G = G::from_u64(86); - let __v_15: G = G::from_u64(147); - let __v_16: G = G::from_u64(193); - let __v_17: G = G::from_u64(55); - let __v_18: G = G::from_u64(180); - let __v_19: G = G::from_u64(229); - let __v_20: G = G::from_u64(77); - let __v_21: G = G::from_u64(18); - let __v_22: G = G::from_u64(172); - let __v_23: G = G::from_u64(9); - let __v_24: G = G::from_u64(170); - let __v_25: G = G::from_u64(85); - let __v_26: G = G::from_u64(152); - let __v_27: G = G::from_u64(99); - let __v_28: G = G::from_u64(149); - let __v_29: G = G::from_u64(75); - let __v_30: G = G::from_u64(101); - let __v_31: G = G::from_u64(135); + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(112); + let __v_2: G = G::from_u64(12); + let __v_3: G = G::from_u64(8); + let __v_4: G = G::from_u64(6); + let __v_5: G = G::from_u64(230); + let __v_6: G = G::from_u64(115); + let __v_7: G = G::from_u64(231); + let __v_8: G = G::from_u64(74); + let __v_9: G = G::from_u64(220); + let __v_10: G = G::from_u64(175); + let __v_11: G = G::from_u64(194); + let __v_12: G = G::from_u64(140); + let __v_13: G = G::from_u64(166); + let __v_14: G = G::from_u64(89); + let __v_15: G = G::from_u64(211); + let __v_16: G = G::from_u64(10); + let __v_17: G = G::from_u64(97); + let __v_18: G = G::from_u64(102); + let __v_19: G = G::from_u64(51); + let __v_20: G = G::from_u64(164); + let __v_21: G = G::from_u64(163); + let __v_22: G = G::from_u64(100); + let __v_23: G = G::from_u64(32); + let __v_24: G = G::from_u64(50); + let __v_25: G = G::from_u64(79); + let __v_26: G = G::from_u64(194); + let __v_27: G = G::from_u64(158); + let __v_28: G = G::from_u64(174); + let __v_29: G = G::from_u64(105); + let __v_30: G = G::from_u64(235); + let __v_31: G = G::from_u64(156); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_215] = [__v_32]; if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -20489,8 +20745,8 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 1; -const IN_216: usize = 1; +const INPUT_SIZE_216: usize = 0; +const IN_216: usize = 0; const OUT_216: usize = 1; fn aiur_fn_216( inp: [G; IN_216], @@ -20498,95 +20754,242 @@ fn aiur_fn_216( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_216], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(216); + let __v_1: G = G::from_u64(56); + let __v_2: G = G::from_u64(187); + let __v_3: G = G::from_u64(107); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(81); + let __v_6: G = G::from_u64(83); + let __v_7: G = G::from_u64(48); + let __v_8: G = G::from_u64(129); + let __v_9: G = G::from_u64(172); + let __v_10: G = G::from_u64(36); + let __v_11: G = G::from_u64(149); + let __v_12: G = G::from_u64(162); + let __v_13: G = G::from_u64(93); + let __v_14: G = G::from_u64(105); + let __v_15: G = G::from_u64(12); + let __v_16: G = G::from_u64(84); + let __v_17: G = G::from_u64(248); + let __v_18: G = G::from_u64(227); + let __v_19: G = G::from_u64(69); + let __v_20: G = G::from_u64(255); + let __v_21: G = G::from_u64(244); + let __v_22: G = G::from_u64(30); + let __v_23: G = G::from_u64(251); + let __v_24: G = G::from_u64(213); + let __v_25: G = G::from_u64(88); + let __v_26: G = G::from_u64(94); + let __v_27: G = G::from_u64(180); + let __v_28: G = G::from_u64(104); + let __v_29: G = G::from_u64(112); + let __v_30: G = G::from_u64(83); + let __v_31: G = G::from_u64(8); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_216] = [__v_32]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_217: usize = 0; +const IN_217: usize = 0; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(214); + let __v_1: G = G::from_u64(22); + let __v_2: G = G::from_u64(50); + let __v_3: G = G::from_u64(125); + let __v_4: G = G::from_u64(79); + let __v_5: G = G::from_u64(194); + let __v_6: G = G::from_u64(25); + let __v_7: G = G::from_u64(189); + let __v_8: G = G::from_u64(113); + let __v_9: G = G::from_u64(20); + let __v_10: G = G::from_u64(186); + let __v_11: G = G::from_u64(212); + let __v_12: G = G::from_u64(108); + let __v_13: G = G::from_u64(208); + let __v_14: G = G::from_u64(134); + let __v_15: G = G::from_u64(107); + let __v_16: G = G::from_u64(239); + let __v_17: G = G::from_u64(226); + let __v_18: G = G::from_u64(85); + let __v_19: G = G::from_u64(21); + let __v_20: G = G::from_u64(24); + let __v_21: G = G::from_u64(181); + let __v_22: G = G::from_u64(191); + let __v_23: G = G::from_u64(46); + let __v_24: G = G::from_u64(16); + let __v_25: G = G::from_u64(181); + let __v_26: G = G::from_u64(202); + let __v_27: G = G::from_u64(201); + let __v_28: G = G::from_u64(51); + let __v_29: G = G::from_u64(129); + let __v_30: G = G::from_u64(251); + let __v_31: G = G::from_u64(119); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_217] = [__v_32]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_218: usize = 0; +const IN_218: usize = 0; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_218], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(136); + let __v_2: G = G::from_u64(249); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(209); + let __v_5: G = G::from_u64(213); + let __v_6: G = G::from_u64(31); + let __v_7: G = G::from_u64(73); + let __v_8: G = G::from_u64(53); + let __v_9: G = G::from_u64(229); + let __v_10: G = G::from_u64(210); + let __v_11: G = G::from_u64(119); + let __v_12: G = G::from_u64(95); + let __v_13: G = G::from_u64(51); + let __v_14: G = G::from_u64(236); + let __v_15: G = G::from_u64(88); + let __v_16: G = G::from_u64(93); + let __v_17: G = G::from_u64(111); + let __v_18: G = G::from_u64(229); + let __v_19: G = G::from_u64(236); + let __v_20: G = G::from_u64(99); + let __v_21: G = G::from_u64(218); + let __v_22: G = G::from_u64(223); + let __v_23: G = G::from_u64(14); + let __v_24: G = G::from_u64(166); + let __v_25: G = G::from_u64(152); + let __v_26: G = G::from_u64(85); + let __v_27: G = G::from_u64(68); + let __v_28: G = G::from_u64(120); + let __v_29: G = G::from_u64(253); + let __v_30: G = G::from_u64(159); + let __v_31: G = G::from_u64(173); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_218] = [__v_32]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_219: usize = 1; +const IN_219: usize = 1; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: [G; IN_219], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_3]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_3]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_5]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_5]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_7]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_7]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_9]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_9]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_11]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_11]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_13]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_216] = [__v_15]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_15]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_216] = [__v_15]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_15]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20605,22 +21008,22 @@ fn aiur_fn_216( }) } -const INPUT_SIZE_217: usize = 3; -const IN_217: usize = 3; -const OUT_217: usize = 2; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_220: usize = 3; +const IN_220: usize = 3; +const OUT_220: usize = 2; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -20629,9 +21032,9 @@ fn aiur_fn_217( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -20641,8 +21044,8 @@ fn aiur_fn_217( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20651,8 +21054,8 @@ fn aiur_fn_217( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20666,14 +21069,14 @@ fn aiur_fn_217( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -20688,13 +21091,13 @@ fn aiur_fn_217( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -20705,17 +21108,17 @@ fn aiur_fn_217( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20724,8 +21127,8 @@ fn aiur_fn_217( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20736,8 +21139,8 @@ fn aiur_fn_217( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20745,63 +21148,63 @@ fn aiur_fn_217( } }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_217] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_217] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_217] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_217] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; @@ -20816,16 +21219,16 @@ fn aiur_fn_217( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -20845,15 +21248,15 @@ fn aiur_fn_217( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20862,8 +21265,8 @@ fn aiur_fn_217( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20874,8 +21277,8 @@ fn aiur_fn_217( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20886,8 +21289,8 @@ fn aiur_fn_217( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20898,8 +21301,8 @@ fn aiur_fn_217( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20912,8 +21315,8 @@ fn aiur_fn_217( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20932,18 +21335,18 @@ fn aiur_fn_217( }) } -const INPUT_SIZE_218: usize = 1; -const IN_218: usize = 1; -const OUT_218: usize = 2; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_221: usize = 1; +const IN_221: usize = 1; +const OUT_221: usize = 2; +fn aiur_fn_221( + inp: [G; IN_221], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -20954,13 +21357,13 @@ fn aiur_fn_218( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -20971,16 +21374,16 @@ fn aiur_fn_218( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); @@ -20991,8 +21394,8 @@ fn aiur_fn_218( let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21001,8 +21404,8 @@ fn aiur_fn_218( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21013,8 +21416,8 @@ fn aiur_fn_218( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21023,18 +21426,18 @@ fn aiur_fn_218( }) } -const INPUT_SIZE_219: usize = 1; -const IN_219: usize = 1; -const OUT_219: usize = 2; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_222: usize = 1; +const IN_222: usize = 1; +const OUT_222: usize = 2; +fn aiur_fn_222( + inp: [G; IN_222], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21045,13 +21448,13 @@ fn aiur_fn_219( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -21070,15 +21473,15 @@ fn aiur_fn_219( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_13, __v_20]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21087,8 +21490,8 @@ fn aiur_fn_219( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21099,8 +21502,8 @@ fn aiur_fn_219( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21111,8 +21514,8 @@ fn aiur_fn_219( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_219] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21121,15 +21524,15 @@ fn aiur_fn_219( }) } -const INPUT_SIZE_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 0; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_223: usize = 1; +const IN_223: usize = 1; +const OUT_223: usize = 0; +fn aiur_fn_223( + inp: [G; IN_223], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -21138,17 +21541,17 @@ fn aiur_fn_220( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_220] = []; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = []; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_220] = []; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_223] = []; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21158,35 +21561,35 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 1; -const IN_221: usize = 1; -const OUT_221: usize = 1; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_224: usize = 1; +const IN_224: usize = 1; +const OUT_224: usize = 1; +fn aiur_fn_224( + inp: [G; IN_224], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_221] = [__v_2]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_2]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_222: usize = 2; -const IN_222: usize = 2; -const OUT_222: usize = 1; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_225: usize = 2; +const IN_225: usize = 2; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21196,18 +21599,18 @@ fn aiur_fn_222( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_222] = [__v_1]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_1]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_222] = [__v_7]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_7]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21217,15 +21620,15 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 1; -const IN_223: usize = 1; -const OUT_223: usize = 1; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_226: usize = 1; +const IN_226: usize = 1; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); @@ -21238,8 +21641,8 @@ fn aiur_fn_223( 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_223] = [__v_6]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_6]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21254,15 +21657,15 @@ fn aiur_fn_223( }) } -const INPUT_SIZE_224: usize = 2; -const IN_224: usize = 2; -const OUT_224: usize = 2; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 2; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21270,8 +21673,8 @@ fn aiur_fn_224( let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_224] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21293,11 +21696,11 @@ fn aiur_fn_224( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_224] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21326,11 +21729,11 @@ fn aiur_fn_224( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21338,8 +21741,8 @@ fn aiur_fn_224( let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_224] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_25, __v_15]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21380,15 +21783,15 @@ fn aiur_fn_224( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21397,8 +21800,8 @@ fn aiur_fn_224( let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_224] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_32, __v_18]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21434,15 +21837,15 @@ fn aiur_fn_224( }) } -const INPUT_SIZE_225: usize = 1; -const IN_225: usize = 1; -const OUT_225: usize = 1; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_228: usize = 1; +const IN_228: usize = 1; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21454,17 +21857,17 @@ fn aiur_fn_225( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -21472,7 +21875,7 @@ fn aiur_fn_225( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); @@ -21480,7 +21883,7 @@ fn aiur_fn_225( let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -21493,26 +21896,26 @@ fn aiur_fn_225( let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_225] = [__v_47]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_47]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_226: usize = 4; -const IN_226: usize = 4; -const OUT_226: usize = 1; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_229: usize = 4; +const IN_229: usize = 4; +const OUT_229: usize = 1; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21524,15 +21927,15 @@ fn aiur_fn_226( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_226] = [__v_1]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_1]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -21544,13 +21947,13 @@ fn aiur_fn_226( let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_226] = [__v_23]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_23]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21560,15 +21963,15 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 2; -const IN_227: usize = 2; -const OUT_227: usize = 1; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_230: usize = 2; +const IN_230: usize = 2; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21586,7 +21989,7 @@ fn aiur_fn_227( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -21606,7 +22009,7 @@ fn aiur_fn_227( 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_333] = { let __args: [G; IN_333] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -21616,58 +22019,58 @@ fn aiur_fn_227( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_227] = [__v_33]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_33]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_227] = [__v_34]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_34]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_228: usize = 2; -const IN_228: usize = 2; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_231: usize = 2; +const IN_231: usize = 2; +const OUT_231: usize = 1; +fn aiur_fn_231( + inp: [G; IN_231], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21680,75 +22083,75 @@ fn aiur_fn_228( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_228] = [__v_7]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_7]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_228] = [__v_0]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_0]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_228] = [__v_0]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_0]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 4; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_232: usize = 1; +const IN_232: usize = 1; +const OUT_232: usize = 4; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_229] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +const OUT_233: usize = 1; +fn aiur_fn_233( + inp: [G; IN_233], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -21782,29 +22185,29 @@ fn aiur_fn_230( let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_31]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_31]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 2; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_234: usize = 2; +const IN_234: usize = 2; +const OUT_234: usize = 2; +fn aiur_fn_234( + inp: [G; IN_234], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_231], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -21814,13 +22217,13 @@ fn aiur_fn_231( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -21828,8 +22231,8 @@ fn aiur_fn_231( 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_231] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21837,14 +22240,14 @@ fn aiur_fn_231( 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_231] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -21854,19 +22257,19 @@ fn aiur_fn_231( 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_231] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -21875,30 +22278,30 @@ fn aiur_fn_231( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_231] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_18, __v_21]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_231] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_22, __v_21]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_231] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21916,8 +22319,8 @@ fn aiur_fn_231( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_231] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_14, __v_17]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21931,59 +22334,59 @@ fn aiur_fn_231( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_231] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_232: usize = 2; -const IN_232: usize = 2; -const OUT_232: usize = 2; -fn aiur_fn_232( - inp: [G; IN_232], +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 2; +fn aiur_fn_235( + inp: [G; IN_235], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_232], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_232] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_4, __v_3]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_232] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_233: usize = 1; -const IN_233: usize = 1; -const OUT_233: usize = 2; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_236: usize = 1; +const IN_236: usize = 1; +const OUT_236: usize = 2; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22000,7 +22403,7 @@ fn aiur_fn_233( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -22008,8 +22411,8 @@ fn aiur_fn_233( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22022,18 +22425,18 @@ fn aiur_fn_233( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_233] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22041,8 +22444,8 @@ fn aiur_fn_233( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22052,8 +22455,8 @@ fn aiur_fn_233( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22061,23 +22464,23 @@ fn aiur_fn_233( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_234: usize = 1; -const IN_234: usize = 1; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_237: usize = 1; +const IN_237: usize = 1; +const OUT_237: usize = 2; +fn aiur_fn_237( + inp: [G; IN_237], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], ExecError> { +) -> Result<[G; OUT_237], 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 }; @@ -22115,8 +22518,8 @@ fn aiur_fn_234( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22131,8 +22534,8 @@ fn aiur_fn_234( match __v_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_234] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_34, __v_31]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22142,8 +22545,8 @@ fn aiur_fn_234( 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22152,15 +22555,15 @@ fn aiur_fn_234( match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_234] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38, __v_31]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38, __v_39]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22174,8 +22577,8 @@ fn aiur_fn_234( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22183,23 +22586,23 @@ fn aiur_fn_234( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_235: usize = 2; -const IN_235: usize = 2; -const OUT_235: usize = 2; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_238: usize = 2; +const IN_238: usize = 2; +const OUT_238: usize = 2; +fn aiur_fn_238( + inp: [G; IN_238], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22207,8 +22610,8 @@ fn aiur_fn_235( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_235] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22216,59 +22619,59 @@ fn aiur_fn_235( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_235] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_236: usize = 1; -const IN_236: usize = 1; -const OUT_236: usize = 4; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 4; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_236] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_237: usize = 2; -const IN_237: usize = 2; -const OUT_237: usize = 1; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +const OUT_240: usize = 1; +fn aiur_fn_240( + inp: [G; IN_240], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], ExecError> { +) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -22323,8 +22726,8 @@ fn aiur_fn_237( 1u64 => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_237] = [__v_38]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_38]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22340,8 +22743,8 @@ fn aiur_fn_237( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_237] = [__v_46]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_46]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22361,8 +22764,8 @@ fn aiur_fn_237( let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_237] = [__v_52]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_52]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22382,8 +22785,8 @@ fn aiur_fn_237( let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_237] = [__v_56]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_56]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22394,212 +22797,212 @@ fn aiur_fn_237( }) } -const INPUT_SIZE_238: usize = 1; -const IN_238: usize = 1; -const OUT_238: usize = 1; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_241: usize = 1; +const IN_241: usize = 1; +const OUT_241: usize = 1; +fn aiur_fn_241( + inp: [G; IN_241], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_3]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_3]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_5]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_5]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_7]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_7]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_9]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_9]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_11]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_11]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_13]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_13]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_15]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_15]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_17]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_17]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_19]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_19]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_21]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_21]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_23]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_23]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_25]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_25]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_27]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_27]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_29]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_29]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_31]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_31]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_238] = [__v_33]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_33]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_238] = [__v_33]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_33]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22636,54 +23039,54 @@ fn aiur_fn_238( }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 1; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_242: usize = 1; +const IN_242: usize = 1; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -22696,21 +23099,21 @@ fn aiur_fn_239( let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); - let __ret: [G; OUT_239] = [__v_29]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_29]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_240: usize = 1; -const IN_240: usize = 1; -const OUT_240: usize = 2; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 2; +fn aiur_fn_243( + inp: [G; IN_243], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22723,8 +23126,8 @@ fn aiur_fn_240( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_240] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_3]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22732,14 +23135,14 @@ fn aiur_fn_240( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -22749,8 +23152,8 @@ fn aiur_fn_240( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22758,18 +23161,18 @@ fn aiur_fn_240( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_240] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22777,23 +23180,23 @@ fn aiur_fn_240( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_241: usize = 2; -const IN_241: usize = 2; -const OUT_241: usize = 2; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_244: usize = 2; +const IN_244: usize = 2; +const OUT_244: usize = 2; +fn aiur_fn_244( + inp: [G; IN_244], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22804,22 +23207,22 @@ fn aiur_fn_241( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_241] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22827,8 +23230,8 @@ fn aiur_fn_241( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_241] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_10, __v_13]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22838,8 +23241,8 @@ fn aiur_fn_241( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_241] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_8, __v_11]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22849,44 +23252,44 @@ fn aiur_fn_241( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_241] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 1; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_245: usize = 1; +const IN_245: usize = 1; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_4]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_4]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_243: usize = 1; -const IN_243: usize = 1; -const OUT_243: usize = 3; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_246: usize = 1; +const IN_246: usize = 1; +const OUT_246: usize = 3; +fn aiur_fn_246( + inp: [G; IN_246], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22903,12 +23306,12 @@ fn aiur_fn_243( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22916,14 +23319,14 @@ fn aiur_fn_243( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_243] = [__v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -22931,12 +23334,12 @@ fn aiur_fn_243( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_243] = [__v_15, __v_16, __v_18]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22945,8 +23348,8 @@ fn aiur_fn_243( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_15, __v_16, __v_19]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_15, __v_16, __v_19]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22959,8 +23362,8 @@ fn aiur_fn_243( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_11, __v_12, __v_15]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_11, __v_12, __v_15]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22971,8 +23374,8 @@ fn aiur_fn_243( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22983,41 +23386,41 @@ fn aiur_fn_243( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_244: usize = 2; -const IN_244: usize = 2; -const OUT_244: usize = 1; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_247: usize = 2; +const IN_247: usize = 2; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -23029,9 +23432,9 @@ fn aiur_fn_244( break '__mc_1 [__v_2]; }, _ => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, @@ -23045,25 +23448,25 @@ fn aiur_fn_244( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_18]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_18]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_245: usize = 4; -const IN_245: usize = 4; -const OUT_245: usize = 1; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_248: usize = 4; +const IN_248: usize = 4; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23072,34 +23475,34 @@ fn aiur_fn_245( let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_6]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_6]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_7]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_7]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_7]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_7]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23108,54 +23511,54 @@ fn aiur_fn_245( }) } -const INPUT_SIZE_246: usize = 3; -const IN_246: usize = 3; -const OUT_246: usize = 1; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_249: usize = 3; +const IN_249: usize = 3; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: [G; IN_249], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_4]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_4]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_11]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_11]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_10]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_10]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23164,21 +23567,21 @@ fn aiur_fn_246( }) } -const INPUT_SIZE_247: usize = 4; -const IN_247: usize = 4; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_250: usize = 4; +const IN_250: usize = 4; +const OUT_250: usize = 1; +fn aiur_fn_250( + inp: [G; IN_250], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -23186,25 +23589,25 @@ fn aiur_fn_247( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_9]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_9]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -23220,54 +23623,54 @@ fn aiur_fn_247( let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_21]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_248: usize = 3; -const IN_248: usize = 3; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_251: usize = 3; +const IN_251: usize = 3; +const OUT_251: usize = 1; +fn aiur_fn_251( + inp: [G; IN_251], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_4]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_4]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23290,29 +23693,29 @@ fn aiur_fn_248( let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_28]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_28]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_27]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_27]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23321,20 +23724,20 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 3; -const IN_249: usize = 3; -const OUT_249: usize = 1; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_252: usize = 3; +const IN_252: usize = 3; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: [G; IN_252], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { @@ -23342,23 +23745,23 @@ fn aiur_fn_249( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_8]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_8]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23368,16 +23771,16 @@ fn aiur_fn_249( } }; let __v_9: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -23388,7 +23791,7 @@ fn aiur_fn_249( }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); @@ -23405,18 +23808,18 @@ fn aiur_fn_249( let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_36]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_36]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23434,10 +23837,10 @@ fn aiur_fn_249( let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_50]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_50]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23446,28 +23849,28 @@ fn aiur_fn_249( }) } -const INPUT_SIZE_250: usize = 3; -const IN_250: usize = 3; -const OUT_250: usize = 2; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_253: usize = 3; +const IN_253: usize = 3; +const OUT_253: usize = 2; +fn aiur_fn_253( + inp: [G; IN_253], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -23483,27 +23886,27 @@ fn aiur_fn_250( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23511,11 +23914,11 @@ fn aiur_fn_250( let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23524,12 +23927,12 @@ fn aiur_fn_250( let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23538,8 +23941,8 @@ fn aiur_fn_250( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23556,25 +23959,25 @@ fn aiur_fn_250( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_250] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23583,8 +23986,8 @@ fn aiur_fn_250( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23595,29 +23998,29 @@ fn aiur_fn_250( }) } -const INPUT_SIZE_251: usize = 4; -const IN_251: usize = 4; -const OUT_251: usize = 2; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_254: usize = 4; +const IN_254: usize = 4; +const OUT_254: usize = 2; +fn aiur_fn_254( + inp: [G; IN_254], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -23626,31 +24029,31 @@ fn aiur_fn_251( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -23669,15 +24072,15 @@ fn aiur_fn_251( let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_33 - __v_35); let __v_37: G = (__v_2 * __v_36); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -23688,12 +24091,12 @@ fn aiur_fn_251( let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23702,34 +24105,34 @@ fn aiur_fn_251( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_251] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -23738,16 +24141,16 @@ fn aiur_fn_251( let __v_21: G = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; @@ -23759,34 +24162,34 @@ fn aiur_fn_251( let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 * __v_33); let __v_35: G = (__v_27 * __v_34); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -23801,12 +24204,12 @@ fn aiur_fn_251( let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23815,8 +24218,8 @@ fn aiur_fn_251( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_251] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23825,15 +24228,15 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 2; -const IN_252: usize = 2; -const OUT_252: usize = 1; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_255: usize = 2; +const IN_255: usize = 2; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23843,18 +24246,18 @@ fn aiur_fn_252( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_252] = [__v_0]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_8]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_8]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23864,264 +24267,264 @@ fn aiur_fn_252( }) } -const INPUT_SIZE_253: usize = 3; -const IN_253: usize = 3; -const OUT_253: usize = 2; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_256: usize = 3; +const IN_256: usize = 3; +const OUT_256: usize = 2; +fn aiur_fn_256( + inp: [G; IN_256], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_11, __v_14]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_29, __v_31]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_31, __v_33]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24130,8 +24533,8 @@ fn aiur_fn_253( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_31, __v_35]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24164,15 +24567,15 @@ fn aiur_fn_253( }) } -const INPUT_SIZE_254: usize = 2; -const IN_254: usize = 2; -const OUT_254: usize = 3; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_257: usize = 2; +const IN_257: usize = 2; +const OUT_257: usize = 3; +fn aiur_fn_257( + inp: [G; IN_257], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24183,7 +24586,7 @@ fn aiur_fn_254( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -24193,22 +24596,22 @@ fn aiur_fn_254( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -24220,8 +24623,8 @@ fn aiur_fn_254( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_254] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24229,8 +24632,8 @@ fn aiur_fn_254( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24240,8 +24643,8 @@ fn aiur_fn_254( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24251,8 +24654,8 @@ fn aiur_fn_254( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24264,23 +24667,23 @@ fn aiur_fn_254( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_255: usize = 2; -const IN_255: usize = 2; -const OUT_255: usize = 1; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_258: usize = 2; +const IN_258: usize = 2; +const OUT_258: usize = 1; +fn aiur_fn_258( + inp: [G; IN_258], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24297,32 +24700,32 @@ fn aiur_fn_255( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_255] = [__v_27]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_27]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); @@ -24342,23 +24745,23 @@ fn aiur_fn_255( let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_255] = [__v_44]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_44]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_256: usize = 1; -const IN_256: usize = 1; -const OUT_256: usize = 1; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_259: usize = 1; +const IN_259: usize = 1; +const OUT_259: usize = 1; +fn aiur_fn_259( + inp: [G; IN_259], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24368,12 +24771,12 @@ fn aiur_fn_256( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_256] = [__v_0]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24383,41 +24786,41 @@ fn aiur_fn_256( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_256] = [__v_0]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_16]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_16]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_256] = [__v_0]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_256] = [__v_0]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24426,33 +24829,33 @@ fn aiur_fn_256( }) } -const INPUT_SIZE_257: usize = 3; -const IN_257: usize = 3; -const OUT_257: usize = 2; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_260: usize = 3; +const IN_260: usize = 3; +const OUT_260: usize = 2; +fn aiur_fn_260( + inp: [G; IN_260], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_257] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); @@ -24463,30 +24866,30 @@ fn aiur_fn_257( let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_257] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 1; -const IN_258: usize = 1; -const OUT_258: usize = 1; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_261: usize = 1; +const IN_261: usize = 1; +const OUT_261: usize = 1; +fn aiur_fn_261( + inp: [G; IN_261], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24503,7 +24906,7 @@ fn aiur_fn_258( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24513,26 +24916,26 @@ fn aiur_fn_258( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_17]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -24542,22 +24945,22 @@ fn aiur_fn_258( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_258] = [__v_26]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_26]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_20]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_20]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24566,39 +24969,39 @@ fn aiur_fn_258( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_15]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_15]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_9]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_9]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_258] = [__v_5]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_5]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_259: usize = 5; -const IN_259: usize = 5; -const OUT_259: usize = 2; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_262: usize = 5; +const IN_262: usize = 5; +const OUT_262: usize = 2; +fn aiur_fn_262( + inp: [G; IN_262], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24614,14 +25017,14 @@ fn aiur_fn_259( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -24631,17 +25034,17 @@ fn aiur_fn_259( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -24650,39 +25053,39 @@ fn aiur_fn_259( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_259] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24698,26 +25101,26 @@ fn aiur_fn_259( }) } -const INPUT_SIZE_260: usize = 3; -const IN_260: usize = 3; -const OUT_260: usize = 2; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_263: usize = 3; +const IN_263: usize = 3; +const OUT_263: usize = 2; +fn aiur_fn_263( + inp: [G; IN_263], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -24732,31 +25135,31 @@ fn aiur_fn_260( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24765,8 +25168,8 @@ fn aiur_fn_260( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24785,33 +25188,33 @@ fn aiur_fn_260( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24820,8 +25223,8 @@ fn aiur_fn_260( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24829,11 +25232,11 @@ fn aiur_fn_260( } }, _ => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_260] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24842,15 +25245,15 @@ fn aiur_fn_260( }) } -const INPUT_SIZE_261: usize = 3; -const IN_261: usize = 3; -const OUT_261: usize = 2; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_264: usize = 3; +const IN_264: usize = 3; +const OUT_264: usize = 2; +fn aiur_fn_264( + inp: [G; IN_264], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24864,40 +25267,40 @@ fn aiur_fn_261( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_261] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24906,8 +25309,8 @@ fn aiur_fn_261( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24918,23 +25321,23 @@ fn aiur_fn_261( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_261] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24943,8 +25346,8 @@ fn aiur_fn_261( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24955,43 +25358,43 @@ fn aiur_fn_261( }) } -const INPUT_SIZE_262: usize = 4; -const IN_262: usize = 4; -const OUT_262: usize = 2; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_265: usize = 4; +const IN_265: usize = 4; +const OUT_265: usize = 2; +fn aiur_fn_265( + inp: [G; IN_265], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_14 - __v_17); let __v_19: G = (__v_13 * __v_18); @@ -25004,24 +25407,24 @@ fn aiur_fn_262( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_22, __v_26]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_262] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_26, __v_25]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25030,18 +25433,18 @@ fn aiur_fn_262( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_26, __v_30]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25050,15 +25453,15 @@ fn aiur_fn_262( }) } -const INPUT_SIZE_263: usize = 4; -const IN_263: usize = 4; -const OUT_263: usize = 1; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_266: usize = 4; +const IN_266: usize = 4; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25074,27 +25477,27 @@ fn aiur_fn_263( let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_17]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_17]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_264: usize = 10; -const IN_264: usize = 10; -const OUT_264: usize = 8; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_267: usize = 10; +const IN_267: usize = 10; +const OUT_267: usize = 8; +fn aiur_fn_267( + inp: [G; IN_267], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25108,8 +25511,8 @@ fn aiur_fn_264( let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25119,15 +25522,15 @@ fn aiur_fn_264( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25136,13 +25539,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25151,13 +25554,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25166,13 +25569,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25181,13 +25584,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25196,13 +25599,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25211,13 +25614,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25226,13 +25629,13 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25241,8 +25644,8 @@ fn aiur_fn_264( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25256,22 +25659,22 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 2; -const IN_265: usize = 2; -const OUT_265: usize = 1; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_268: usize = 2; +const IN_268: usize = 2; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_265] = [__v_0]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_0]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25284,17 +25687,17 @@ fn aiur_fn_265( 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_265] = [__v_7]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_7]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_7]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_7]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25306,15 +25709,15 @@ fn aiur_fn_265( }) } -const INPUT_SIZE_266: usize = 1; -const IN_266: usize = 1; -const OUT_266: usize = 1; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_269: usize = 1; +const IN_269: usize = 1; +const OUT_269: usize = 1; +fn aiur_fn_269( + inp: [G; IN_269], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -25326,7 +25729,7 @@ fn aiur_fn_266( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25336,7 +25739,7 @@ fn aiur_fn_266( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -25350,7 +25753,7 @@ fn aiur_fn_266( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -25377,8 +25780,8 @@ fn aiur_fn_266( let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_37]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_37]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -25387,8 +25790,8 @@ fn aiur_fn_266( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_39]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_39]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25399,23 +25802,23 @@ fn aiur_fn_266( _ => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_35]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_35]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_267: usize = 1; -const IN_267: usize = 1; -const OUT_267: usize = 1; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_270: usize = 1; +const IN_270: usize = 1; +const OUT_270: usize = 1; +fn aiur_fn_270( + inp: [G; IN_270], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; @@ -25433,40 +25836,40 @@ fn aiur_fn_267( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_12]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_12]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_13]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_13]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_13]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -25475,8 +25878,8 @@ fn aiur_fn_267( let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_13]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25486,15 +25889,15 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 2; -const IN_268: usize = 2; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_271: usize = 2; +const IN_271: usize = 2; +const OUT_271: usize = 1; +fn aiur_fn_271( + inp: [G; IN_271], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25514,23 +25917,23 @@ fn aiur_fn_268( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_14]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_14]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_17]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_17]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25540,15 +25943,15 @@ fn aiur_fn_268( }) } -const INPUT_SIZE_269: usize = 5; -const IN_269: usize = 5; -const OUT_269: usize = 1; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_272: usize = 5; +const IN_272: usize = 5; +const OUT_272: usize = 1; +fn aiur_fn_272( + inp: [G; IN_272], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25578,15 +25981,15 @@ fn aiur_fn_269( 0u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_28]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -25595,139 +25998,139 @@ fn aiur_fn_269( let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_26]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_26]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_28]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_28]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_28]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_29]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_29]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_30]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_30]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_27]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_27]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_27]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_27]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -25735,10 +26138,10 @@ fn aiur_fn_269( let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_269] = [__v_28]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25753,15 +26156,15 @@ fn aiur_fn_269( }) } -const INPUT_SIZE_270: usize = 17; -const IN_270: usize = 17; -const OUT_270: usize = 12; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_273: usize = 17; +const IN_273: usize = 17; +const OUT_273: usize = 12; +fn aiur_fn_273( + inp: [G; IN_273], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25782,9 +26185,9 @@ fn aiur_fn_270( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -25792,8 +26195,8 @@ fn aiur_fn_270( 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -25811,15 +26214,15 @@ fn aiur_fn_270( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_270] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25831,15 +26234,15 @@ fn aiur_fn_270( }) } -const INPUT_SIZE_271: usize = 14; -const IN_271: usize = 14; -const OUT_271: usize = 12; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_274: usize = 14; +const IN_274: usize = 14; +const OUT_274: usize = 12; +fn aiur_fn_274( + inp: [G; IN_274], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25857,29 +26260,29 @@ fn aiur_fn_271( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_272: usize = 14; -const IN_272: usize = 14; -const OUT_272: usize = 12; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_275: usize = 14; +const IN_275: usize = 14; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: [G; IN_275], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25897,29 +26300,29 @@ fn aiur_fn_272( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_272] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_273: usize = 1; -const IN_273: usize = 1; -const OUT_273: usize = 1; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_276: usize = 1; +const IN_276: usize = 1; +const OUT_276: usize = 1; +fn aiur_fn_276( + inp: [G; IN_276], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_276], 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 }; @@ -25962,17 +26365,17 @@ fn aiur_fn_273( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_37]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_37]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_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_273] = [__v_39]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_39]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25982,15 +26385,15 @@ fn aiur_fn_273( }) } -const INPUT_SIZE_274: usize = 2; -const IN_274: usize = 2; -const OUT_274: usize = 34; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_277: usize = 2; +const IN_277: usize = 2; +const OUT_277: usize = 34; +fn aiur_fn_277( + inp: [G; IN_277], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26035,14 +26438,14 @@ fn aiur_fn_274( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_274] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -26077,8 +26480,8 @@ fn aiur_fn_274( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_274] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26090,15 +26493,15 @@ fn aiur_fn_274( }) } -const INPUT_SIZE_275: usize = 33; -const IN_275: usize = 33; -const OUT_275: usize = 12; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_278: usize = 33; +const IN_278: usize = 33; +const OUT_278: usize = 12; +fn aiur_fn_278( + inp: [G; IN_278], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26135,7 +26538,7 @@ fn aiur_fn_275( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; @@ -26144,26 +26547,26 @@ fn aiur_fn_275( let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_276: usize = 40; -const IN_276: usize = 40; -const OUT_276: usize = 12; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_279: usize = 40; +const IN_279: usize = 40; +const OUT_279: usize = 12; +fn aiur_fn_279( + inp: [G; IN_279], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26207,7 +26610,7 @@ fn aiur_fn_276( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; @@ -26219,23 +26622,23 @@ fn aiur_fn_276( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_277: usize = 6; -const IN_277: usize = 6; -const OUT_277: usize = 1; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_280: usize = 6; +const IN_280: usize = 6; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26260,25 +26663,25 @@ fn aiur_fn_277( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_277] = [__v_19]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_19]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_277] = [__v_23]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_23]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26290,15 +26693,15 @@ fn aiur_fn_277( }) } -const INPUT_SIZE_278: usize = 50; -const IN_278: usize = 50; -const OUT_278: usize = 12; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_281: usize = 50; +const IN_281: usize = 50; +const OUT_281: usize = 12; +fn aiur_fn_281( + inp: [G; IN_281], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26352,10 +26755,10 @@ fn aiur_fn_278( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; @@ -26368,23 +26771,23 @@ fn aiur_fn_278( let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_278] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_279: usize = 1; -const IN_279: usize = 1; -const OUT_279: usize = 48; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_282: usize = 1; +const IN_282: usize = 1; +const OUT_282: usize = 48; +fn aiur_fn_282( + inp: [G; IN_282], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_282], 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 }; @@ -26428,7 +26831,7 @@ fn aiur_fn_279( let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -26493,21 +26896,21 @@ fn aiur_fn_279( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_279] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_280: usize = 1; -const IN_280: usize = 1; -const OUT_280: usize = 1; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_283: usize = 1; +const IN_283: usize = 1; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_283], 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 }; @@ -26556,8 +26959,8 @@ fn aiur_fn_280( let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_280] = [__v_39]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_39]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26567,15 +26970,15 @@ fn aiur_fn_280( }) } -const INPUT_SIZE_281: usize = 1; -const IN_281: usize = 1; -const OUT_281: usize = 1; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_284: usize = 1; +const IN_284: usize = 1; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; @@ -26619,43 +27022,43 @@ fn aiur_fn_281( let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_281] = [__v_37]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_37]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_282: usize = 2; -const IN_282: usize = 2; -const OUT_282: usize = 1; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_285: usize = 2; +const IN_285: usize = 2; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_2]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_282] = [__v_2]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_2]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26664,14 +27067,14 @@ fn aiur_fn_282( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_2]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_282] = [__v_2]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26683,15 +27086,15 @@ fn aiur_fn_282( }) } -const INPUT_SIZE_283: usize = 14; -const IN_283: usize = 14; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_286: usize = 14; +const IN_286: usize = 14; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26709,22 +27112,22 @@ fn aiur_fn_283( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_283] = [__v_17]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_17]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_283] = [__v_15]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_15]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26733,18 +27136,18 @@ fn aiur_fn_283( }) } -const INPUT_SIZE_284: usize = 1; -const IN_284: usize = 1; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_287: usize = 1; +const IN_287: usize = 1; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -26797,11 +27200,11 @@ fn aiur_fn_284( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { @@ -26823,7 +27226,7 @@ fn aiur_fn_284( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -26837,15 +27240,15 @@ fn aiur_fn_284( let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_63]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_63]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26859,15 +27262,15 @@ fn aiur_fn_284( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_64]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_64]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26881,17 +27284,17 @@ fn aiur_fn_284( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_64]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_64]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_49]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_49]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26901,10 +27304,10 @@ fn aiur_fn_284( _ => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_50]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_50]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26916,10 +27319,10 @@ fn aiur_fn_284( let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_51]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_51]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26929,10 +27332,10 @@ fn aiur_fn_284( _ => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_50]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_50]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26944,7 +27347,7 @@ fn aiur_fn_284( let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -26958,8 +27361,8 @@ fn aiur_fn_284( let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_67]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_67]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26971,15 +27374,15 @@ fn aiur_fn_284( }) } -const INPUT_SIZE_285: usize = 10; -const IN_285: usize = 10; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_288: usize = 10; +const IN_288: usize = 10; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: [G; IN_288], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26991,7 +27394,7 @@ fn aiur_fn_285( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -27044,7 +27447,7 @@ fn aiur_fn_285( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -27092,11 +27495,11 @@ fn aiur_fn_285( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27110,8 +27513,8 @@ fn aiur_fn_285( let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_285] = [__v_117]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_117]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27128,19 +27531,19 @@ fn aiur_fn_285( }) } -const INPUT_SIZE_286: usize = 2; -const IN_286: usize = 2; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +const INPUT_SIZE_289: usize = 2; +const IN_289: usize = 2; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_286], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27193,7 +27596,7 @@ fn aiur_fn_286( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27241,9 +27644,9 @@ fn aiur_fn_286( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27257,8 +27660,8 @@ fn aiur_fn_286( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_108]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_108]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27275,20 +27678,20 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 3; -const IN_287: usize = 3; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_290: usize = 3; +const IN_290: usize = 3; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27341,7 +27744,7 @@ fn aiur_fn_287( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27391,7 +27794,7 @@ fn aiur_fn_287( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27426,9 +27829,9 @@ fn aiur_fn_287( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -27442,8 +27845,8 @@ fn aiur_fn_287( let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_143]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_290] = [__v_143]; + if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27462,19 +27865,19 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 2; -const IN_288: usize = 2; -const OUT_288: usize = 1; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_291: usize = 2; +const IN_291: usize = 2; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27527,7 +27930,7 @@ fn aiur_fn_288( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27575,9 +27978,9 @@ fn aiur_fn_288( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27591,8 +27994,8 @@ fn aiur_fn_288( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_288] = [__v_108]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_291] = [__v_108]; + if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27609,15 +28012,15 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 2; -const IN_289: usize = 2; -const OUT_289: usize = 45; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_292: usize = 2; +const IN_292: usize = 2; +const OUT_292: usize = 45; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27673,14 +28076,14 @@ fn aiur_fn_289( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_289] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27726,8 +28129,8 @@ fn aiur_fn_289( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_289] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27739,15 +28142,15 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 1; -const IN_290: usize = 1; -const OUT_290: usize = 8; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_293: usize = 1; +const IN_293: usize = 1; +const OUT_293: usize = 8; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -27768,26 +28171,26 @@ fn aiur_fn_290( if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_290] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_291: usize = 3; -const IN_291: usize = 3; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_294: usize = 3; +const IN_294: usize = 3; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27833,7 +28236,7 @@ fn aiur_fn_291( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -27920,46 +28323,46 @@ fn aiur_fn_291( let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_114]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_114]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_292: usize = 2; -const IN_292: usize = 2; -const OUT_292: usize = 1; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_295: usize = 2; +const IN_295: usize = 2; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_3]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_3]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_293: usize = 4; -const IN_293: usize = 4; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_296: usize = 4; +const IN_296: usize = 4; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28018,21 +28421,21 @@ fn aiur_fn_293( let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_293] = [__v_53]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_53]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_293] = [__v_56]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_56]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28042,15 +28445,15 @@ fn aiur_fn_293( }) } -const INPUT_SIZE_294: usize = 1; -const IN_294: usize = 1; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_297: usize = 1; +const IN_297: usize = 1; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_297], 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 }; @@ -28060,57 +28463,57 @@ fn aiur_fn_294( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_4]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_4]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_4]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_6]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_6]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_6]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_4]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28120,15 +28523,15 @@ fn aiur_fn_294( }) } -const INPUT_SIZE_295: usize = 2; -const IN_295: usize = 2; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_298: usize = 2; +const IN_298: usize = 2; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: [G; IN_298], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28145,14 +28548,14 @@ fn aiur_fn_295( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28164,16 +28567,16 @@ fn aiur_fn_295( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28185,19 +28588,19 @@ fn aiur_fn_295( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28209,19 +28612,19 @@ fn aiur_fn_295( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28235,14 +28638,14 @@ fn aiur_fn_295( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_295] = [__v_9]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_9]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28254,15 +28657,15 @@ fn aiur_fn_295( }) } -const INPUT_SIZE_296: usize = 2; -const IN_296: usize = 2; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28279,14 +28682,14 @@ fn aiur_fn_296( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_8]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_8]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28302,8 +28705,8 @@ fn aiur_fn_296( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_296] = [__v_8]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28311,8 +28714,8 @@ fn aiur_fn_296( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_9]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_9]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28320,15 +28723,15 @@ fn aiur_fn_296( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28353,15 +28756,15 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 2; -const IN_297: usize = 2; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28372,8 +28775,8 @@ fn aiur_fn_297( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_5]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_5]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28384,8 +28787,8 @@ fn aiur_fn_297( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_8]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28393,25 +28796,25 @@ fn aiur_fn_297( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_9]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_9]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_10]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_10]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28436,15 +28839,15 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28461,14 +28864,14 @@ fn aiur_fn_298( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28484,15 +28887,15 @@ fn aiur_fn_298( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28507,15 +28910,15 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 2; -const IN_299: usize = 2; -const OUT_299: usize = 2; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 2; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28531,8 +28934,8 @@ fn aiur_fn_299( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_5, __v_10]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28542,8 +28945,8 @@ fn aiur_fn_299( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28551,18 +28954,18 @@ fn aiur_fn_299( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_7, __v_1]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28582,15 +28985,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 3; -const IN_300: usize = 3; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_303: usize = 3; +const IN_303: usize = 3; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28607,8 +29010,8 @@ fn aiur_fn_300( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_300] = [__v_11]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_11]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28623,8 +29026,8 @@ fn aiur_fn_300( let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_300] = [__v_11]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_11]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28632,11 +29035,11 @@ fn aiur_fn_300( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_300] = [__v_12]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_12]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28646,13 +29049,13 @@ fn aiur_fn_300( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_300] = [__v_13]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_13]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_300] = [__v_0]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28679,15 +29082,15 @@ fn aiur_fn_300( }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 1; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_304: usize = 2; +const IN_304: usize = 2; +const OUT_304: usize = 1; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28704,14 +29107,14 @@ fn aiur_fn_301( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28727,8 +29130,8 @@ fn aiur_fn_301( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28748,24 +29151,24 @@ fn aiur_fn_301( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_14]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_14]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_14]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_14]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_13]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_13]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28786,15 +29189,15 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 1; -const IN_302: usize = 1; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_305: usize = 1; +const IN_305: usize = 1; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_305], 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 }; @@ -28804,8 +29207,8 @@ fn aiur_fn_302( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_302] = [__v_4]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_4]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28814,18 +29217,18 @@ fn aiur_fn_302( let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_302] = [__v_5]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_5]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_302] = [__v_6]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_6]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28842,15 +29245,15 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_306: usize = 2; +const IN_306: usize = 2; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28860,8 +29263,8 @@ fn aiur_fn_303( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_0]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28871,8 +29274,8 @@ fn aiur_fn_303( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_0]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28890,21 +29293,21 @@ fn aiur_fn_303( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_15]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_15]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_14]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_14]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28912,18 +29315,18 @@ fn aiur_fn_303( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_17]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_17]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_15]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_15]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28957,23 +29360,23 @@ fn aiur_fn_303( }) } -const INPUT_SIZE_304: usize = 3; -const IN_304: usize = 3; -const OUT_304: usize = 1; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_307: usize = 3; +const IN_307: usize = 3; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_0]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -28983,15 +29386,15 @@ fn aiur_fn_304( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_304] = [__v_6]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_6]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_0]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29000,25 +29403,25 @@ fn aiur_fn_304( } }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_304] = [__v_3]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_3]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_305: usize = 3; -const IN_305: usize = 3; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_308: usize = 3; +const IN_308: usize = 3; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29038,8 +29441,8 @@ fn aiur_fn_305( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_14]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_14]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29049,7 +29452,7 @@ fn aiur_fn_305( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -29059,13 +29462,13 @@ fn aiur_fn_305( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_13]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_13]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_305] = [__v_0]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_0]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29080,17 +29483,17 @@ fn aiur_fn_305( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_15]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_15]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_12]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_12]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29104,15 +29507,15 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 4; -const IN_306: usize = 4; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_309: usize = 4; +const IN_309: usize = 4; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29137,8 +29540,8 @@ fn aiur_fn_306( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_19]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_19]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29148,17 +29551,17 @@ fn aiur_fn_306( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_14]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_14]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29172,17 +29575,17 @@ fn aiur_fn_306( let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_20]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_20]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_13]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_13]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29196,15 +29599,15 @@ fn aiur_fn_306( }) } -const INPUT_SIZE_307: usize = 4; -const IN_307: usize = 4; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_310: usize = 4; +const IN_310: usize = 4; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29216,63 +29619,63 @@ fn aiur_fn_307( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_7]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_7]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_9]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_8]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_8]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_7]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_7]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_10]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_10]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_307] = [__v_3]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_3]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_9]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29289,15 +29692,15 @@ fn aiur_fn_307( }) } -const INPUT_SIZE_308: usize = 5; -const IN_308: usize = 5; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_311: usize = 5; +const IN_311: usize = 5; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29310,55 +29713,55 @@ fn aiur_fn_308( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_8]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_8]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_11]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_11]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_9]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_9]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_9]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_9]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_12]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_12]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29367,17 +29770,17 @@ fn aiur_fn_308( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_308] = [__v_11]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_11]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29392,15 +29795,15 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 2; -const IN_309: usize = 2; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29410,19 +29813,19 @@ fn aiur_fn_309( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_309] = [__v_0]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_0]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_8]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_8]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29432,15 +29835,15 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 2; -const IN_310: usize = 2; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_313: usize = 2; +const IN_313: usize = 2; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29450,8 +29853,8 @@ fn aiur_fn_310( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_0]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29467,18 +29870,18 @@ fn aiur_fn_310( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_12]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29511,7 +29914,7 @@ fn aiur_fn_310( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -29552,7 +29955,7 @@ fn aiur_fn_310( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29568,10 +29971,10 @@ fn aiur_fn_310( }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_16]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_16]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29587,15 +29990,15 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 1; -const IN_311: usize = 1; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_314: usize = 1; +const IN_314: usize = 1; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_314], 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 }; @@ -29604,8 +30007,8 @@ fn aiur_fn_311( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_311] = [__v_0]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29623,15 +30026,15 @@ fn aiur_fn_311( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_311] = [__v_0]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29640,8 +30043,8 @@ fn aiur_fn_311( } }, _ => { - let __ret: [G; OUT_311] = [__v_0]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29655,21 +30058,21 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_315: usize = 2; +const IN_315: usize = 2; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -29684,14 +30087,14 @@ fn aiur_fn_312( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_312] = [__v_10]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_10]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29707,8 +30110,8 @@ fn aiur_fn_312( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_10]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29724,27 +30127,27 @@ fn aiur_fn_312( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_19]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_19]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_19]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_19]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29754,16 +30157,16 @@ fn aiur_fn_312( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_18]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_18]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_17]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_17]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29784,15 +30187,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 3; -const IN_313: usize = 3; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_316: usize = 3; +const IN_316: usize = 3; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29804,8 +30207,8 @@ fn aiur_fn_313( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_6]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_6]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29815,14 +30218,14 @@ fn aiur_fn_313( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29833,7 +30236,7 @@ fn aiur_fn_313( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -29846,15 +30249,15 @@ fn aiur_fn_313( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_313] = [__v_12]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_12]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_12]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_12]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29873,15 +30276,15 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 2; -const IN_314: usize = 2; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29892,8 +30295,8 @@ fn aiur_fn_314( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_5]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_5]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29908,15 +30311,15 @@ fn aiur_fn_314( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29933,15 +30336,15 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 4; -const IN_315: usize = 4; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_318: usize = 4; +const IN_318: usize = 4; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29954,8 +30357,8 @@ fn aiur_fn_315( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_7]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_7]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29965,31 +30368,31 @@ fn aiur_fn_315( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_11]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_11]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_315] = [__v_12]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_12]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_12]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_12]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30008,15 +30411,15 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 3; -const IN_316: usize = 3; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_319: usize = 3; +const IN_319: usize = 3; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30028,8 +30431,8 @@ fn aiur_fn_316( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_6]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_6]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30045,15 +30448,15 @@ fn aiur_fn_316( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_10]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_10]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30062,10 +30465,10 @@ fn aiur_fn_316( } }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_9]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_9]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30079,15 +30482,15 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 2; -const IN_317: usize = 2; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_320: usize = 2; +const IN_320: usize = 2; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30098,8 +30501,8 @@ fn aiur_fn_317( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_5]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_5]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30115,7 +30518,7 @@ fn aiur_fn_317( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30125,25 +30528,25 @@ fn aiur_fn_317( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_9]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_10]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_10]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_10]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_10]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30165,15 +30568,15 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 3; -const IN_318: usize = 3; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_321: usize = 3; +const IN_321: usize = 3; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30185,8 +30588,8 @@ fn aiur_fn_318( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_318] = [__v_6]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_6]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30195,20 +30598,20 @@ fn aiur_fn_318( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_9]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_9]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_9]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_9]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30225,15 +30628,15 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 1; -const IN_319: usize = 1; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_322: usize = 1; +const IN_322: usize = 1; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -30253,35 +30656,35 @@ fn aiur_fn_319( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_19]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_19]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_320: usize = 2; -const IN_320: usize = 2; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_320], +const INPUT_SIZE_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_3]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_3]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30292,19 +30695,19 @@ fn aiur_fn_320( match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_6]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_6]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_8]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_8]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30316,36 +30719,36 @@ fn aiur_fn_320( }) } -const INPUT_SIZE_321: usize = 2; -const IN_321: usize = 2; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_321] = [__v_3]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_3]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_5]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_5]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30355,24 +30758,24 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 2; -const IN_322: usize = 2; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30380,13 +30783,13 @@ fn aiur_fn_322( let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_1]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_0]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30395,43 +30798,43 @@ fn aiur_fn_322( } }, _ => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_6]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_4]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_4]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_323] = [__v_0]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30441,8 +30844,8 @@ fn aiur_fn_323( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_323] = [__v_1]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30452,33 +30855,33 @@ fn aiur_fn_323( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_323] = [__v_0]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_323] = [__v_1]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_323] = [__v_0]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_11]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_11]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30502,15 +30905,15 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_327: usize = 2; +const IN_327: usize = 2; +const OUT_327: usize = 1; +fn aiur_fn_327( + inp: [G; IN_327], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30518,8 +30921,8 @@ fn aiur_fn_324( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_3]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_3]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30536,14 +30939,14 @@ fn aiur_fn_324( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30555,16 +30958,16 @@ fn aiur_fn_324( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30576,19 +30979,19 @@ fn aiur_fn_324( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_324] = [__v_11]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_11]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30600,19 +31003,19 @@ fn aiur_fn_324( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_324] = [__v_11]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_11]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30628,22 +31031,22 @@ fn aiur_fn_324( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_10]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_10]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_10]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_10]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_9]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30657,15 +31060,15 @@ fn aiur_fn_324( }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 1; +fn aiur_fn_328( + inp: [G; IN_328], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30675,20 +31078,20 @@ fn aiur_fn_325( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_325] = [__v_6]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_6]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_6]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_6]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30698,48 +31101,48 @@ fn aiur_fn_325( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_325] = [__v_5]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_5]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_329: usize = 2; +const IN_329: usize = 2; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_1]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_1]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_326] = [__v_0]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_0]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30750,8 +31153,8 @@ fn aiur_fn_326( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_326] = [__v_10]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_10]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30761,15 +31164,15 @@ fn aiur_fn_326( }) } -const INPUT_SIZE_327: usize = 1; -const IN_327: usize = 1; -const OUT_327: usize = 2; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_330: usize = 1; +const IN_330: usize = 1; +const OUT_330: usize = 2; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -30780,12 +31183,12 @@ fn aiur_fn_327( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30793,15 +31196,15 @@ fn aiur_fn_327( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_327] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30809,23 +31212,23 @@ fn aiur_fn_327( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 2; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_331: usize = 2; +const IN_331: usize = 2; +const OUT_331: usize = 2; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30837,31 +31240,31 @@ fn aiur_fn_328( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_328] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_328] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_329: usize = 2; -const IN_329: usize = 2; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_332: usize = 2; +const IN_332: usize = 2; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30874,26 +31277,26 @@ fn aiur_fn_329( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_7]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_7]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_5]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_5]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_6]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30903,24 +31306,24 @@ fn aiur_fn_329( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_329] = [__v_1]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_1]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_329] = [__v_0]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_0]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_11]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_11]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30939,15 +31342,15 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 1; -const IN_330: usize = 1; -const OUT_330: usize = 1; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_333: usize = 1; +const IN_333: usize = 1; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_333], 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 }; @@ -30959,48 +31362,48 @@ fn aiur_fn_330( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 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_330] = [__v_6]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_6]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_7]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_6]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_6]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31010,15 +31413,15 @@ fn aiur_fn_330( }) } -const INPUT_SIZE_331: usize = 2; -const IN_331: usize = 2; -const OUT_331: usize = 1; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31031,47 +31434,47 @@ fn aiur_fn_331( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_331] = [__v_8]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_331] = [__v_5]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_5]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31081,15 +31484,15 @@ fn aiur_fn_331( }) } -const INPUT_SIZE_332: usize = 2; -const IN_332: usize = 2; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_335: usize = 2; +const IN_335: usize = 2; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31102,19 +31505,19 @@ fn aiur_fn_332( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_7]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_7]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_8]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_8]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31124,15 +31527,15 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 2; -const IN_333: usize = 2; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_336: usize = 2; +const IN_336: usize = 2; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31142,30 +31545,30 @@ fn aiur_fn_333( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_333] = [__v_0]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_0]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_5]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_5]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_337: usize = 2; +const IN_337: usize = 2; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31179,94 +31582,94 @@ fn aiur_fn_334( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_9]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_9]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_9]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_10]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_10]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_10]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_10]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_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_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31276,15 +31679,15 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 2; -const IN_335: usize = 2; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_338: usize = 2; +const IN_338: usize = 2; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31315,14 +31718,14 @@ fn aiur_fn_335( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_335] = [__v_22]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_22]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31342,8 +31745,8 @@ fn aiur_fn_335( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_22]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31351,16 +31754,16 @@ fn aiur_fn_335( let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_23]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_23]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_23]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_23]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31380,15 +31783,15 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 2; -const IN_336: usize = 2; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_339: usize = 2; +const IN_339: usize = 2; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31405,14 +31808,14 @@ fn aiur_fn_336( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31425,24 +31828,24 @@ fn aiur_fn_336( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_336] = [__v_8]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_9]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_9]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_336] = [__v_9]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_9]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31459,15 +31862,15 @@ fn aiur_fn_336( }) } -const INPUT_SIZE_337: usize = 4; -const IN_337: usize = 4; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_340: usize = 4; +const IN_340: usize = 4; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31477,16 +31880,16 @@ fn aiur_fn_337( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_4]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_4]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31494,16 +31897,16 @@ fn aiur_fn_337( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_4]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_4]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31515,15 +31918,15 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 1; -const IN_338: usize = 1; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_341: usize = 1; +const IN_341: usize = 1; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -31535,77 +31938,77 @@ fn aiur_fn_338( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_338] = [__v_6]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_6]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_5]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_5]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_5]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_7]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_7]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_8]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_8]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_5]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_5]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31615,59 +32018,59 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 3; -const IN_339: usize = 3; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_342: usize = 3; +const IN_342: usize = 3; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_8]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_8]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_340: usize = 2; -const IN_340: usize = 2; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_343: usize = 2; +const IN_343: usize = 2; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_340] = [__v_1]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_1]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_340] = [__v_0]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_0]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31677,57 +32080,57 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 1; -const IN_341: usize = 1; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_344: usize = 1; +const IN_344: usize = 1; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_344], 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_341] = [__v_1]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_1]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_341] = [__v_2]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_2]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_342: usize = 2; -const IN_342: usize = 2; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_345: usize = 2; +const IN_345: usize = 2; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_342] = [__v_0]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_0]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_342] = [__v_1]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_1]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31737,15 +32140,15 @@ fn aiur_fn_342( }) } -const INPUT_SIZE_343: usize = 3; -const IN_343: usize = 3; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_346: usize = 3; +const IN_346: usize = 3; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31761,14 +32164,14 @@ fn aiur_fn_343( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_8]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_8]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31778,37 +32181,37 @@ fn aiur_fn_343( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_8]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_8]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31817,31 +32220,31 @@ fn aiur_fn_343( } }, 4u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_7]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31851,27 +32254,27 @@ fn aiur_fn_343( }) } -const INPUT_SIZE_344: usize = 4; -const IN_344: usize = 4; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_347: usize = 4; +const IN_347: usize = 4; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_344] = [__v_5]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_5]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31879,10 +32282,10 @@ fn aiur_fn_344( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_9]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31892,38 +32295,38 @@ fn aiur_fn_344( }) } -const INPUT_SIZE_345: usize = 5; -const IN_345: usize = 5; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_348: usize = 5; +const IN_348: usize = 5; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_345] = [__v_6]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_6]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_345] = [__v_7]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_7]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31931,10 +32334,10 @@ fn aiur_fn_345( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_11]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_11]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31949,60 +32352,60 @@ fn aiur_fn_345( }) } -const INPUT_SIZE_346: usize = 2; -const IN_346: usize = 2; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_349: usize = 2; +const IN_349: usize = 2; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_4]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_4]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_347: usize = 2; -const IN_347: usize = 2; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_347] = [__v_2]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_2]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_7]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32012,15 +32415,15 @@ fn aiur_fn_347( }) } -const INPUT_SIZE_348: usize = 1; -const IN_348: usize = 1; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_351: usize = 1; +const IN_351: usize = 1; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_351], 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 }; @@ -32030,13 +32433,13 @@ fn aiur_fn_348( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_348] = [__v_7]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_7]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32046,44 +32449,44 @@ fn aiur_fn_348( }) } -const INPUT_SIZE_349: usize = 2; -const IN_349: usize = 2; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_352: usize = 2; +const IN_352: usize = 2; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_349] = [__v_2]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_2]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_349] = [__v_2]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_2]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_349] = [__v_7]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32095,15 +32498,15 @@ fn aiur_fn_349( }) } -const INPUT_SIZE_350: usize = 2; -const IN_350: usize = 2; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_353: usize = 2; +const IN_353: usize = 2; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32112,31 +32515,31 @@ fn aiur_fn_350( 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_350] = [__v_4]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_4]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_350] = [__v_0]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_0]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_350] = [__v_7]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_7]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32148,19 +32551,19 @@ fn aiur_fn_350( }) } -const INPUT_SIZE_351: usize = 2; -const IN_351: usize = 2; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_354: usize = 2; +const IN_354: usize = 2; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); @@ -32169,30 +32572,30 @@ fn aiur_fn_351( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_351] = [__v_6]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_6]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_351] = [__v_6]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_6]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_352: usize = 2; -const IN_352: usize = 2; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_355: usize = 2; +const IN_355: usize = 2; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32208,14 +32611,14 @@ fn aiur_fn_352( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); - let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_7]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); - let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_7]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32225,59 +32628,59 @@ fn aiur_fn_352( }, 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_8]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_8]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32287,100 +32690,100 @@ fn aiur_fn_352( }) } -const INPUT_SIZE_353: usize = 3; -const IN_353: usize = 3; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_356: usize = 3; +const IN_356: usize = 3; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_354: usize = 4; -const IN_354: usize = 4; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_357: usize = 4; +const IN_357: usize = 4; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_10]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_10]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_355: usize = 3; -const IN_355: usize = 3; -const OUT_355: usize = 1; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_358: usize = 3; +const IN_358: usize = 3; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_355] = [__v_0]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_0]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_355] = [__v_0]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_0]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_5]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_5]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32392,15 +32795,15 @@ fn aiur_fn_355( }) } -const INPUT_SIZE_356: usize = 3; -const IN_356: usize = 3; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_359: usize = 3; +const IN_359: usize = 3; +const OUT_359: usize = 1; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], ExecError> { +) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32412,90 +32815,90 @@ fn aiur_fn_356( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_7]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_9]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_9]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_11]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_11]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_13]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_13]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_13]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_13]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_7]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_9]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_9]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32505,15 +32908,15 @@ fn aiur_fn_356( }) } -const INPUT_SIZE_357: usize = 3; -const IN_357: usize = 3; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 1; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32524,8 +32927,8 @@ fn aiur_fn_357( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_357] = [__v_6]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_6]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32533,8 +32936,8 @@ fn aiur_fn_357( let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_357] = [__v_7]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_7]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32544,15 +32947,15 @@ fn aiur_fn_357( }) } -const INPUT_SIZE_358: usize = 5; -const IN_358: usize = 5; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_361: usize = 5; +const IN_361: usize = 5; +const OUT_361: usize = 1; +fn aiur_fn_361( + inp: [G; IN_361], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32560,56 +32963,56 @@ fn aiur_fn_358( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_358] = [__v_11]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_11]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 1; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_362: usize = 3; +const IN_362: usize = 3; +const OUT_362: usize = 1; +fn aiur_fn_362( + inp: [G; IN_362], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], ExecError> { +) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_0]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_0]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_5]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_5]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32621,15 +33024,15 @@ fn aiur_fn_359( }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 1; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_363: usize = 3; +const IN_363: usize = 3; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: [G; IN_363], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_360], ExecError> { +) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32644,8 +33047,8 @@ fn aiur_fn_360( let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_360] = [__v_0]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_0]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32653,8 +33056,8 @@ fn aiur_fn_360( let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_11]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_11]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32666,88 +33069,88 @@ fn aiur_fn_360( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_9]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_9]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_11]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_11]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_13]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_13]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_13]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_9]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_9]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32757,15 +33160,15 @@ fn aiur_fn_360( }) } -const INPUT_SIZE_361: usize = 2; -const IN_361: usize = 2; -const OUT_361: usize = 1; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_364: usize = 2; +const IN_364: usize = 2; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: [G; IN_364], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], ExecError> { +) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32780,150 +33183,150 @@ fn aiur_fn_361( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_7]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_7]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_7]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_7]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_362: usize = 3; -const IN_362: usize = 3; -const OUT_362: usize = 1; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_365: usize = 3; +const IN_365: usize = 3; +const OUT_365: usize = 1; +fn aiur_fn_365( + inp: [G; IN_365], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], ExecError> { +) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_362] = [__v_4]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_4]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_6]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_363: usize = 4; -const IN_363: usize = 4; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_366: usize = 4; +const IN_366: usize = 4; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: [G; IN_366], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], ExecError> { +) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_363] = [__v_5]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_5]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_363] = [__v_6]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 + __v_6); - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_8]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_8]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32932,48 +33335,48 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 3; -const IN_364: usize = 3; -const OUT_364: usize = 1; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_367: usize = 3; +const IN_367: usize = 3; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_364] = [__v_0]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_367] = [__v_0]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_367] = [__v_6]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_367] = [__v_9]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32985,15 +33388,15 @@ fn aiur_fn_364( }) } -const INPUT_SIZE_365: usize = 3; -const IN_365: usize = 3; -const OUT_365: usize = 1; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_368: usize = 3; +const IN_368: usize = 3; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], ExecError> { +) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33005,90 +33408,90 @@ fn aiur_fn_365( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_7]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_11]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_11]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_13]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_13]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_13]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_13]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_7]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33098,15 +33501,15 @@ fn aiur_fn_365( }) } -const INPUT_SIZE_366: usize = 3; -const IN_366: usize = 3; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], ExecError> { +) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33118,8 +33521,8 @@ fn aiur_fn_366( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_6]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33127,10 +33530,10 @@ fn aiur_fn_366( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_6]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33139,8 +33542,8 @@ fn aiur_fn_366( let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_366] = [__v_9]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33152,15 +33555,15 @@ fn aiur_fn_366( }) } -const INPUT_SIZE_367: usize = 5; -const IN_367: usize = 5; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_370: usize = 5; +const IN_370: usize = 5; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33168,71 +33571,71 @@ fn aiur_fn_367( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_367] = [__v_11]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_11]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_371: usize = 3; +const IN_371: usize = 3; +const OUT_371: usize = 1; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_368] = [__v_0]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_0]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_368] = [__v_0]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_0]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_8]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_8]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_9]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33246,33 +33649,33 @@ fn aiur_fn_368( }) } -const INPUT_SIZE_369: usize = 3; -const IN_369: usize = 3; -const OUT_369: usize = 1; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_372: usize = 3; +const IN_372: usize = 3; +const OUT_372: usize = 1; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_8]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_8]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33280,8 +33683,8 @@ fn aiur_fn_369( let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_9]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33291,15 +33694,15 @@ fn aiur_fn_369( }) } -const INPUT_SIZE_370: usize = 3; -const IN_370: usize = 3; -const OUT_370: usize = 1; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_373: usize = 3; +const IN_373: usize = 3; +const OUT_373: usize = 1; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], ExecError> { +) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33311,90 +33714,90 @@ fn aiur_fn_370( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_7]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_7]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_9]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_9]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_11]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_11]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_13]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_13]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_13]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_13]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_7]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_7]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_9]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_9]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33404,15 +33807,15 @@ fn aiur_fn_370( }) } -const INPUT_SIZE_371: usize = 5; -const IN_371: usize = 5; -const OUT_371: usize = 1; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_374: usize = 5; +const IN_374: usize = 5; +const OUT_374: usize = 1; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33420,30 +33823,30 @@ fn aiur_fn_371( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_371] = [__v_11]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_11]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_372: usize = 3; -const IN_372: usize = 3; -const OUT_372: usize = 3; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_375: usize = 3; +const IN_375: usize = 3; +const OUT_375: usize = 3; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33463,17 +33866,17 @@ fn aiur_fn_372( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_372] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33482,23 +33885,23 @@ fn aiur_fn_372( } }, _ => { - let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_373: usize = 3; -const IN_373: usize = 3; -const OUT_373: usize = 1; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_376: usize = 3; +const IN_376: usize = 3; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33506,56 +33909,56 @@ fn aiur_fn_373( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_10]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_10]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_14]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_14]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_12]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_12]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_374: usize = 3; -const IN_374: usize = 3; -const OUT_374: usize = 1; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_377: usize = 3; +const IN_377: usize = 3; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33567,90 +33970,90 @@ fn aiur_fn_374( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_10]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_10]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_7]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_7]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_9]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_7]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_7]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_375: usize = 5; -const IN_375: usize = 5; -const OUT_375: usize = 1; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_378: usize = 5; +const IN_378: usize = 5; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_375] = [__v_11]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_11]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33661,7 +34064,7 @@ fn aiur_fn_375( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -33679,21 +34082,21 @@ fn aiur_fn_375( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_375] = [__v_30]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_30]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_375] = [__v_30]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_30]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33701,10 +34104,10 @@ fn aiur_fn_375( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_375] = [__v_17]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_17]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33713,315 +34116,315 @@ fn aiur_fn_375( }) } -const INPUT_SIZE_376: usize = 0; -const IN_376: usize = 0; -const OUT_376: usize = 1; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_379: usize = 0; +const IN_379: usize = 0; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(116); - let __v_1: G = G::from_u64(89); - 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_0: G = G::from_u64(167); + let __v_1: G = G::from_u64(233); + let __v_2: G = G::from_u64(168); + let __v_3: G = G::from_u64(184); + let __v_4: G = G::from_u64(74); + let __v_5: G = G::from_u64(47); + let __v_6: G = G::from_u64(233); + let __v_7: G = G::from_u64(108); + let __v_8: G = G::from_u64(194); + let __v_9: G = G::from_u64(4); + let __v_10: G = G::from_u64(172); + let __v_11: G = G::from_u64(201); + let __v_12: G = G::from_u64(61); 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_14: G = G::from_u64(209); + let __v_15: G = G::from_u64(54); + let __v_16: G = G::from_u64(109); + let __v_17: G = G::from_u64(157); + let __v_18: G = G::from_u64(5); + let __v_19: G = G::from_u64(116); + let __v_20: G = G::from_u64(170); + let __v_21: G = G::from_u64(240); + let __v_22: G = G::from_u64(240); + let __v_23: G = G::from_u64(150); + let __v_24: G = G::from_u64(51); + let __v_25: G = G::from_u64(210); + let __v_26: G = G::from_u64(176); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(148); + let __v_29: G = G::from_u64(201); + let __v_30: G = G::from_u64(232); + let __v_31: G = G::from_u64(96); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_376] = [__v_32]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_32]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_377: usize = 0; -const IN_377: usize = 0; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_380: usize = 0; +const IN_380: usize = 0; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(171); - let __v_1: G = G::from_u64(55); - 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_0: G = G::from_u64(106); + let __v_1: G = G::from_u64(247); + let __v_2: G = G::from_u64(56); + let __v_3: G = G::from_u64(9); + let __v_4: G = G::from_u64(166); + let __v_5: G = G::from_u64(18); + let __v_6: G = G::from_u64(138); + let __v_7: G = G::from_u64(220); + let __v_8: G = G::from_u64(185); + let __v_9: G = G::from_u64(197); + let __v_10: G = G::from_u64(215); + let __v_11: G = G::from_u64(231); + let __v_12: G = G::from_u64(58); + let __v_13: G = G::from_u64(48); + let __v_14: G = G::from_u64(194); + let __v_15: G = G::from_u64(141); + let __v_16: G = G::from_u64(72); + let __v_17: G = G::from_u64(157); + let __v_18: G = G::from_u64(186); + let __v_19: G = G::from_u64(77); + let __v_20: G = G::from_u64(144); + let __v_21: G = G::from_u64(87); + let __v_22: G = G::from_u64(23); + let __v_23: G = G::from_u64(5); + let __v_24: G = G::from_u64(90); + let __v_25: G = G::from_u64(194); + let __v_26: G = G::from_u64(237); + let __v_27: G = G::from_u64(215); + let __v_28: G = G::from_u64(85); + let __v_29: G = G::from_u64(255); + let __v_30: G = G::from_u64(167); + let __v_31: G = G::from_u64(19); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_377] = [__v_32]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_380] = [__v_32]; + if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_378: usize = 0; -const IN_378: usize = 0; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_381: usize = 0; +const IN_381: usize = 0; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(57); - let __v_1: G = G::from_u64(138); - 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_0: G = G::from_u64(29); + let __v_1: G = G::from_u64(255); + let __v_2: G = G::from_u64(253); + let __v_3: G = G::from_u64(228); + let __v_4: G = G::from_u64(140); + let __v_5: G = G::from_u64(78); + let __v_6: G = G::from_u64(246); + let __v_7: G = G::from_u64(101); + let __v_8: G = G::from_u64(59); + let __v_9: G = G::from_u64(149); + let __v_10: G = G::from_u64(236); + let __v_11: G = G::from_u64(197); + let __v_12: G = G::from_u64(71); + let __v_13: G = G::from_u64(77); + let __v_14: G = G::from_u64(238); + let __v_15: G = G::from_u64(139); + let __v_16: G = G::from_u64(153); + let __v_17: G = G::from_u64(70); + let __v_18: G = G::from_u64(16); + let __v_19: G = G::from_u64(8); + let __v_20: G = G::from_u64(210); + let __v_21: G = G::from_u64(109); + let __v_22: G = G::from_u64(128); + let __v_23: G = G::from_u64(202); + let __v_24: G = G::from_u64(56); + let __v_25: G = G::from_u64(79); + let __v_26: G = G::from_u64(30); + let __v_27: G = G::from_u64(89); + let __v_28: G = G::from_u64(233); + let __v_29: G = G::from_u64(39); + let __v_30: G = G::from_u64(113); + let __v_31: G = G::from_u64(77); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_378] = [__v_32]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_381] = [__v_32]; + if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_379: usize = 0; -const IN_379: usize = 0; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_382: usize = 0; +const IN_382: usize = 0; +const OUT_382: usize = 1; +fn aiur_fn_382( + inp: [G; IN_382], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], ExecError> { +) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(136); - let __v_1: G = G::from_u64(38); - let __v_2: G = G::from_u64(102); - let __v_3: G = G::from_u64(119); - let __v_4: G = G::from_u64(254); - let __v_5: G = G::from_u64(231); - let __v_6: G = G::from_u64(116); - let __v_7: G = G::from_u64(209); - let __v_8: G = G::from_u64(9); - let __v_9: G = G::from_u64(134); - let __v_10: G = G::from_u64(126); - let __v_11: G = G::from_u64(75); - let __v_12: G = G::from_u64(34); - let __v_13: G = G::from_u64(64); - let __v_14: G = G::from_u64(40); - let __v_15: G = G::from_u64(26); - let __v_16: G = G::from_u64(162); - let __v_17: G = G::from_u64(238); - let __v_18: G = G::from_u64(18); - let __v_19: G = G::from_u64(217); - let __v_20: G = G::from_u64(121); - let __v_21: G = G::from_u64(32); - let __v_22: G = G::from_u64(193); - let __v_23: G = G::from_u64(23); - let __v_24: G = G::from_u64(28); - let __v_25: G = G::from_u64(245); - let __v_26: G = G::from_u64(193); - let __v_27: G = G::from_u64(246); - let __v_28: G = G::from_u64(200); - let __v_29: G = G::from_u64(125); - let __v_30: G = G::from_u64(236); - let __v_31: G = G::from_u64(246); + let __v_0: G = G::from_u64(10); + let __v_1: G = G::from_u64(76); + let __v_2: G = G::from_u64(199); + let __v_3: G = G::from_u64(201); + let __v_4: G = G::from_u64(48); + let __v_5: G = G::from_u64(221); + let __v_6: G = G::from_u64(103); + let __v_7: G = G::from_u64(38); + let __v_8: G = G::from_u64(187); + let __v_9: G = G::from_u64(215); + let __v_10: G = G::from_u64(241); + let __v_11: G = G::from_u64(188); + let __v_12: G = G::from_u64(63); + let __v_13: G = G::from_u64(234); + let __v_14: G = G::from_u64(104); + let __v_15: G = G::from_u64(93); + let __v_16: G = G::from_u64(245); + let __v_17: G = G::from_u64(246); + let __v_18: G = G::from_u64(102); + let __v_19: G = G::from_u64(84); + let __v_20: G = G::from_u64(157); + let __v_21: G = G::from_u64(101); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(62); + let __v_24: G = G::from_u64(118); + let __v_25: G = G::from_u64(111); + let __v_26: G = G::from_u64(229); + let __v_27: G = G::from_u64(116); + let __v_28: G = G::from_u64(110); + let __v_29: G = G::from_u64(196); + let __v_30: G = G::from_u64(89); + let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_379] = [__v_32]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_32]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_380: usize = 0; -const IN_380: usize = 0; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_383: usize = 0; +const IN_383: usize = 0; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], ExecError> { +) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(141); - let __v_1: G = G::from_u64(196); - 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_0: G = G::from_u64(86); + let __v_1: G = G::from_u64(2); + let __v_2: G = G::from_u64(118); + let __v_3: G = G::from_u64(249); + let __v_4: G = G::from_u64(94); + let __v_5: G = G::from_u64(13); + let __v_6: G = G::from_u64(147); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(123); + let __v_9: G = G::from_u64(140); + let __v_10: G = G::from_u64(5); + let __v_11: G = G::from_u64(9); + let __v_12: G = G::from_u64(121); + let __v_13: G = G::from_u64(149); + let __v_14: G = G::from_u64(191); + let __v_15: G = G::from_u64(130); + let __v_16: G = G::from_u64(135); + let __v_17: G = G::from_u64(99); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(194); + let __v_20: G = G::from_u64(231); + let __v_21: G = G::from_u64(227); + let __v_22: G = G::from_u64(16); + let __v_23: G = G::from_u64(51); + let __v_24: G = G::from_u64(224); + let __v_25: G = G::from_u64(161); + let __v_26: G = G::from_u64(148); + let __v_27: G = G::from_u64(129); + let __v_28: G = G::from_u64(158); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(141); + let __v_31: G = G::from_u64(48); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_380] = [__v_32]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_32]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_381: usize = 0; -const IN_381: usize = 0; -const OUT_381: usize = 1; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_384: usize = 0; +const IN_384: usize = 0; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: [G; IN_384], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], ExecError> { +) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(18); - let __v_1: G = G::from_u64(73); - let __v_2: G = G::from_u64(132); - let __v_3: G = G::from_u64(188); - let __v_4: G = G::from_u64(185); - let __v_5: G = G::from_u64(82); - let __v_6: G = G::from_u64(8); - let __v_7: G = G::from_u64(160); - let __v_8: G = G::from_u64(243); - let __v_9: G = G::from_u64(11); - let __v_10: G = G::from_u64(182); - let __v_11: G = G::from_u64(157); - let __v_12: G = G::from_u64(103); - let __v_13: G = G::from_u64(54); - let __v_14: G = G::from_u64(211); - let __v_15: G = G::from_u64(213); - let __v_16: G = G::from_u64(148); - let __v_17: G = G::from_u64(4); - let __v_18: G = G::from_u64(225); - let __v_19: G = G::from_u64(21); - let __v_20: G = G::from_u64(226); - let __v_21: G = G::from_u64(32); - let __v_22: G = G::from_u64(32); - let __v_23: G = G::from_u64(67); - let __v_24: G = G::from_u64(253); - let __v_25: G = G::from_u64(163); - let __v_26: G = G::from_u64(211); - let __v_27: G = G::from_u64(78); - let __v_28: G = G::from_u64(1); - let __v_29: G = G::from_u64(176); - let __v_30: G = G::from_u64(173); - let __v_31: G = G::from_u64(22); + let __v_0: G = G::from_u64(2); + let __v_1: G = G::from_u64(243); + let __v_2: G = G::from_u64(88); + let __v_3: G = G::from_u64(128); + let __v_4: G = G::from_u64(143); + let __v_5: G = G::from_u64(212); + let __v_6: G = G::from_u64(50); + let __v_7: G = G::from_u64(141); + let __v_8: G = G::from_u64(116); + let __v_9: G = G::from_u64(133); + let __v_10: G = G::from_u64(5); + let __v_11: G = G::from_u64(130); + let __v_12: G = G::from_u64(211); + let __v_13: G = G::from_u64(96); + let __v_14: G = G::from_u64(141); + let __v_15: G = G::from_u64(45); + let __v_16: G = G::from_u64(49); + let __v_17: G = G::from_u64(228); + let __v_18: G = G::from_u64(149); + let __v_19: G = G::from_u64(25); + let __v_20: G = G::from_u64(180); + let __v_21: G = G::from_u64(198); + let __v_22: G = G::from_u64(198); + let __v_23: G = G::from_u64(107); + let __v_24: G = G::from_u64(54); + let __v_25: G = G::from_u64(5); + let __v_26: G = G::from_u64(251); + let __v_27: G = G::from_u64(230); + let __v_28: G = G::from_u64(244); + let __v_29: G = G::from_u64(45); + let __v_30: G = G::from_u64(60); + let __v_31: G = G::from_u64(93); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_381] = [__v_32]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_32]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_382: usize = 4; -const IN_382: usize = 4; -const OUT_382: usize = 2; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_385: usize = 4; +const IN_385: usize = 4; +const OUT_385: usize = 2; +fn aiur_fn_385( + inp: [G; IN_385], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], ExecError> { +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -34032,8 +34435,8 @@ fn aiur_fn_382( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34046,7 +34449,7 @@ fn aiur_fn_382( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -34057,12 +34460,12 @@ fn aiur_fn_382( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34073,25 +34476,25 @@ fn aiur_fn_382( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -34125,7 +34528,7 @@ fn aiur_fn_382( let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); @@ -34154,13 +34557,13 @@ fn aiur_fn_382( let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_382] = [__v_77, __v_78]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_77, __v_78]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34169,8 +34572,8 @@ fn aiur_fn_382( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_42, __v_46]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_42, __v_46]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34181,8 +34584,8 @@ fn aiur_fn_382( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34193,8 +34596,8 @@ fn aiur_fn_382( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_29, __v_33]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_29, __v_33]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34209,8 +34612,8 @@ fn aiur_fn_382( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34221,8 +34624,8 @@ fn aiur_fn_382( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34231,15 +34634,15 @@ fn aiur_fn_382( }) } -const INPUT_SIZE_383: usize = 1; -const IN_383: usize = 1; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_386: usize = 1; +const IN_386: usize = 1; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: [G; IN_386], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -34249,10 +34652,10 @@ fn aiur_fn_383( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_383] = [__v_5]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_5]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34267,23 +34670,23 @@ fn aiur_fn_383( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_15]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_15]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_384: usize = 2; -const IN_384: usize = 2; -const OUT_384: usize = 1; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_387: usize = 2; +const IN_387: usize = 2; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34296,19 +34699,19 @@ fn aiur_fn_384( 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_384] = [__v_7]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_7]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_8]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_8]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34318,28 +34721,28 @@ fn aiur_fn_384( }) } -const INPUT_SIZE_385: usize = 3; -const IN_385: usize = 3; -const OUT_385: usize = 2; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_388: usize = 3; +const IN_388: usize = 3; +const OUT_388: usize = 2; +fn aiur_fn_388( + inp: [G; IN_388], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -34354,31 +34757,31 @@ fn aiur_fn_385( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34387,8 +34790,8 @@ fn aiur_fn_385( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34407,33 +34810,33 @@ fn aiur_fn_385( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34442,8 +34845,8 @@ fn aiur_fn_385( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34451,11 +34854,11 @@ fn aiur_fn_385( } }, _ => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_385] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34464,19 +34867,19 @@ fn aiur_fn_385( }) } -const INPUT_SIZE_386: usize = 2; -const IN_386: usize = 2; -const OUT_386: usize = 1; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_389: usize = 2; +const IN_389: usize = 2; +const OUT_389: usize = 1; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_386], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __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]; @@ -34484,8 +34887,8 @@ fn aiur_fn_386( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_386] = [__v_2]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_2]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -34495,26 +34898,26 @@ fn aiur_fn_386( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_386] = [__v_2]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_2]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_17]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_17]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34529,18 +34932,18 @@ fn aiur_fn_386( }) } -const INPUT_SIZE_387: usize = 1; -const IN_387: usize = 1; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_390: usize = 1; +const IN_390: usize = 1; +const OUT_390: usize = 1; +fn aiur_fn_390( + inp: [G; IN_390], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; @@ -34550,7 +34953,7 @@ fn aiur_fn_387( break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -34560,7 +34963,7 @@ fn aiur_fn_387( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -34570,7 +34973,7 @@ fn aiur_fn_387( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -34580,7 +34983,7 @@ fn aiur_fn_387( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -34590,7 +34993,7 @@ fn aiur_fn_387( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -34600,7 +35003,7 @@ fn aiur_fn_387( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -34610,7 +35013,7 @@ fn aiur_fn_387( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -34620,7 +35023,7 @@ fn aiur_fn_387( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -34630,7 +35033,7 @@ fn aiur_fn_387( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -34640,7 +35043,7 @@ fn aiur_fn_387( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; @@ -34650,7 +35053,7 @@ fn aiur_fn_387( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; @@ -34660,7 +35063,7 @@ fn aiur_fn_387( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -34670,7 +35073,7 @@ fn aiur_fn_387( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; @@ -34680,7 +35083,7 @@ fn aiur_fn_387( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; @@ -34690,7 +35093,7 @@ fn aiur_fn_387( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; @@ -34739,64 +35142,64 @@ fn aiur_fn_387( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_387] = [__v_4]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_4]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_387] = [__v_5]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_5]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); - let __ret: [G; OUT_387] = [__v_6]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_6]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); - let __ret: [G; OUT_387] = [__v_7]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_7]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_387] = [__v_8]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_8]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); - let __ret: [G; OUT_387] = [__v_9]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_9]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_387] = [__v_9]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_9]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34813,71 +35216,71 @@ fn aiur_fn_387( }) } -const INPUT_SIZE_388: usize = 4; -const IN_388: usize = 4; -const OUT_388: usize = 2; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_391: usize = 4; +const IN_391: usize = 4; +const OUT_391: usize = 2; +fn aiur_fn_391( + inp: [G; IN_391], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34886,52 +35289,52 @@ fn aiur_fn_388( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_389: usize = 3; -const IN_389: usize = 3; -const OUT_389: usize = 2; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_392: usize = 3; +const IN_392: usize = 3; +const OUT_392: usize = 2; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_389] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_389] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34940,8 +35343,8 @@ fn aiur_fn_389( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34950,19 +35353,19 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 2; -const IN_390: usize = 2; -const OUT_390: usize = 2; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_393: usize = 2; +const IN_393: usize = 2; +const OUT_393: usize = 2; +fn aiur_fn_393( + inp: [G; IN_393], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34973,33 +35376,33 @@ fn aiur_fn_390( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_390] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35008,8 +35411,8 @@ fn aiur_fn_390( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_390] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35018,19 +35421,19 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 2; -const IN_391: usize = 2; -const OUT_391: usize = 2; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_394: usize = 2; +const IN_394: usize = 2; +const OUT_394: usize = 2; +fn aiur_fn_394( + inp: [G; IN_394], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35041,33 +35444,33 @@ fn aiur_fn_391( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_391] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35076,8 +35479,8 @@ fn aiur_fn_391( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_391] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35086,21 +35489,21 @@ fn aiur_fn_391( }) } -const INPUT_SIZE_392: usize = 2; -const IN_392: usize = 2; -const OUT_392: usize = 2; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 2; +fn aiur_fn_395( + inp: [G; IN_395], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { +) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35110,13 +35513,13 @@ fn aiur_fn_392( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -35124,10 +35527,10 @@ fn aiur_fn_392( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_392] = [__v_14, __v_16]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_14, __v_16]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35136,8 +35539,8 @@ fn aiur_fn_392( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35148,8 +35551,8 @@ fn aiur_fn_392( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35160,47 +35563,47 @@ fn aiur_fn_392( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_393: usize = 5; -const IN_393: usize = 5; -const OUT_393: usize = 1; -fn aiur_fn_393( - inp: [G; IN_393], +const INPUT_SIZE_396: usize = 5; +const IN_396: usize = 5; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_393], ExecError> { +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_7]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_7]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_393] = [__v_6]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_6]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -35217,52 +35620,52 @@ fn aiur_fn_393( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_22]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_23]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_23]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_20]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_20]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_22]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_22]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35273,10 +35676,10 @@ fn aiur_fn_393( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -35291,46 +35694,46 @@ fn aiur_fn_393( let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_393] = [__v_24]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_24]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_28]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_28]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_393] = [__v_27]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_27]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_30]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_30]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_393] = [__v_27]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_27]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35338,10 +35741,10 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_28]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_28]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35349,10 +35752,10 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_20]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_20]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35361,20 +35764,20 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; -const OUT_394: usize = 2; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_397: usize = 2; +const IN_397: usize = 2; +const OUT_397: usize = 2; +fn aiur_fn_397( + inp: [G; IN_397], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], ExecError> { +) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -35382,7 +35785,7 @@ fn aiur_fn_394( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -35392,22 +35795,22 @@ fn aiur_fn_394( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35418,23 +35821,23 @@ fn aiur_fn_394( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 5; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_398: usize = 2; +const IN_398: usize = 2; +const OUT_398: usize = 5; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], ExecError> { +) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35447,14 +35850,14 @@ fn aiur_fn_395( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; - let __ret: [G; OUT_395] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -35472,8 +35875,8 @@ fn aiur_fn_395( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __v_14: G = (__v_13 - __v_7); - let __ret: [G; OUT_395] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35514,8 +35917,8 @@ fn aiur_fn_395( let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_395] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35558,8 +35961,8 @@ fn aiur_fn_395( let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_395] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35602,23 +36005,23 @@ fn aiur_fn_395( let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_395] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_396: usize = 1; -const IN_396: usize = 1; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_399: usize = 1; +const IN_399: usize = 1; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], ExecError> { +) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35630,33 +36033,33 @@ fn aiur_fn_396( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_12]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_12]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); @@ -35666,37 +36069,37 @@ fn aiur_fn_396( let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_21]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_21]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_396] = [__v_0]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_0]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_396] = [__v_0]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_0]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_397: usize = 9; -const IN_397: usize = 9; -const OUT_397: usize = 2; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_400: usize = 9; +const IN_400: usize = 9; +const OUT_400: usize = 2; +fn aiur_fn_400( + inp: [G; IN_400], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35720,7 +36123,7 @@ fn aiur_fn_397( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -35731,14 +36134,14 @@ fn aiur_fn_397( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -35747,30 +36150,30 @@ fn aiur_fn_397( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_21, __v_25]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_21, __v_25]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_30, __v_31]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_30, __v_31]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35785,34 +36188,34 @@ fn aiur_fn_397( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_398: usize = 5; -const IN_398: usize = 5; -const OUT_398: usize = 1; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_401: usize = 5; +const IN_401: usize = 5; +const OUT_401: usize = 1; +fn aiur_fn_401( + inp: [G; IN_401], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], ExecError> { +) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35827,12 +36230,12 @@ fn aiur_fn_398( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_14]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_14]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -35849,27 +36252,27 @@ fn aiur_fn_398( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_34]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_34]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_27]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_27]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35878,63 +36281,63 @@ fn aiur_fn_398( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_13]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_13]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_399: usize = 3; -const IN_399: usize = 3; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_402: usize = 3; +const IN_402: usize = 3; +const OUT_402: usize = 1; +fn aiur_fn_402( + inp: [G; IN_402], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], ExecError> { +) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_399] = [__v_13]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_13]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_400: usize = 2; -const IN_400: usize = 2; -const OUT_400: usize = 1; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_403: usize = 2; +const IN_403: usize = 2; +const OUT_403: usize = 1; +fn aiur_fn_403( + inp: [G; IN_403], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], ExecError> { +) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35944,7 +36347,7 @@ fn aiur_fn_400( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -35961,41 +36364,41 @@ fn aiur_fn_400( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_24]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_24]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_400] = [__v_2]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_2]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_400] = [__v_2]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_2]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_401: usize = 10; -const IN_401: usize = 10; -const OUT_401: usize = 2; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_404: usize = 10; +const IN_404: usize = 10; +const OUT_404: usize = 2; +fn aiur_fn_404( + inp: [G; IN_404], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], ExecError> { +) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36010,7 +36413,7 @@ fn aiur_fn_401( let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -36020,40 +36423,40 @@ fn aiur_fn_401( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_401] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_401] = [__v_17, __v_16]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_17, __v_16]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -36065,40 +36468,40 @@ fn aiur_fn_401( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_32, __v_33]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_32, __v_33]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_401] = [__v_44, __v_43]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_44, __v_43]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36107,13 +36510,13 @@ fn aiur_fn_401( } }, _ => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36124,18 +36527,18 @@ fn aiur_fn_401( }) } -const INPUT_SIZE_402: usize = 1; -const IN_402: usize = 1; -const OUT_402: usize = 4; -fn aiur_fn_402( - inp: [G; IN_402], +const INPUT_SIZE_405: usize = 1; +const IN_405: usize = 1; +const OUT_405: usize = 4; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36145,7 +36548,7 @@ fn aiur_fn_402( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -36163,10 +36566,10 @@ fn aiur_fn_402( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_20, __v_13, __v_21, __v_2]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_20, __v_13, __v_21, __v_2]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36208,8 +36611,8 @@ fn aiur_fn_402( let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_402] = [__v_20, __v_21, __v_54, __v_57]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_20, __v_21, __v_54, __v_57]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36253,23 +36656,23 @@ fn aiur_fn_402( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_402] = [__v_7, __v_8, __v_41, __v_44]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_7, __v_8, __v_41, __v_44]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_403: usize = 2; -const IN_403: usize = 2; -const OUT_403: usize = 3; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_406: usize = 2; +const IN_406: usize = 2; +const OUT_406: usize = 3; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36287,8 +36690,8 @@ fn aiur_fn_403( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_403] = [__v_7, __v_8, __v_12]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_7, __v_8, __v_12]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36298,17 +36701,17 @@ fn aiur_fn_403( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_403] = [__v_8, __v_4, __v_5]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_8, __v_4, __v_5]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_403] = [__v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36322,15 +36725,15 @@ fn aiur_fn_403( }) } -const INPUT_SIZE_404: usize = 9; -const IN_404: usize = 9; -const OUT_404: usize = 2; -fn aiur_fn_404( - inp: [G; IN_404], +const INPUT_SIZE_407: usize = 9; +const IN_407: usize = 9; +const OUT_407: usize = 2; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_404], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36354,8 +36757,8 @@ fn aiur_fn_404( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36372,8 +36775,8 @@ fn aiur_fn_404( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -36382,7 +36785,7 @@ fn aiur_fn_404( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -36392,12 +36795,12 @@ fn aiur_fn_404( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_24, __v_28]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_24, __v_28]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -36420,7 +36823,7 @@ fn aiur_fn_404( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -36429,16 +36832,16 @@ fn aiur_fn_404( 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_404] = [__v_40, __v_44]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_40, __v_44]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; @@ -36449,14 +36852,14 @@ fn aiur_fn_404( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_44, __v_48]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_44, __v_48]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -36465,31 +36868,31 @@ fn aiur_fn_404( let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_46, __v_50]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_46, __v_50]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_56, __v_57]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_56, __v_57]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36504,8 +36907,8 @@ fn aiur_fn_404( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36516,8 +36919,8 @@ fn aiur_fn_404( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36528,8 +36931,8 @@ fn aiur_fn_404( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_37, __v_41]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_37, __v_41]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36550,15 +36953,15 @@ fn aiur_fn_404( }) } -const INPUT_SIZE_405: usize = 2; -const IN_405: usize = 2; -const OUT_405: usize = 2; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_408: usize = 2; +const IN_408: usize = 2; +const OUT_408: usize = 2; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36571,7 +36974,7 @@ fn aiur_fn_405( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36582,8 +36985,8 @@ fn aiur_fn_405( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_405] = [__v_12, __v_9]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_12, __v_9]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36621,8 +37024,8 @@ fn aiur_fn_405( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_12, __v_45]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_12, __v_45]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36662,8 +37065,8 @@ fn aiur_fn_405( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36678,11 +37081,11 @@ fn aiur_fn_405( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_405] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36720,8 +37123,8 @@ fn aiur_fn_405( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36730,15 +37133,15 @@ fn aiur_fn_405( }) } -const INPUT_SIZE_406: usize = 5; -const IN_406: usize = 5; -const OUT_406: usize = 1; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_409: usize = 5; +const IN_409: usize = 5; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36748,8 +37151,8 @@ fn aiur_fn_406( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_406] = [__v_0]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_0]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36760,28 +37163,28 @@ fn aiur_fn_406( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_13]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_13]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_407: usize = 1; -const IN_407: usize = 1; -const OUT_407: usize = 1; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_410: usize = 1; +const IN_410: usize = 1; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -36798,38 +37201,38 @@ fn aiur_fn_407( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_16]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_16]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_407] = [__v_14]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_14]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_408: usize = 2; -const IN_408: usize = 2; -const OUT_408: usize = 1; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_411: usize = 2; +const IN_411: usize = 2; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -36882,10 +37285,10 @@ fn aiur_fn_408( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_50]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_50]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36894,8 +37297,8 @@ fn aiur_fn_408( let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_54]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_54]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36904,15 +37307,15 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 6; -const IN_409: usize = 6; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_412: usize = 6; +const IN_412: usize = 6; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], ExecError> { +) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36924,12 +37327,12 @@ fn aiur_fn_409( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_409] = [__v_7]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -36946,32 +37349,32 @@ fn aiur_fn_409( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_409] = [__v_22]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_22]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_24]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_24]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_409] = [__v_20]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_20]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36980,22 +37383,22 @@ fn aiur_fn_409( }) } -const INPUT_SIZE_410: usize = 2; -const IN_410: usize = 2; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_413: usize = 2; +const IN_413: usize = 2; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], ExecError> { +) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_410] = [__v_0]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_0]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37008,15 +37411,15 @@ fn aiur_fn_410( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_8]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_8]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_410] = [__v_0]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_0]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37025,15 +37428,15 @@ fn aiur_fn_410( }) } -const INPUT_SIZE_411: usize = 2; -const IN_411: usize = 2; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_414: usize = 2; +const IN_414: usize = 2; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], ExecError> { +) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37044,43 +37447,43 @@ fn aiur_fn_411( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_411] = [__v_7]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_7]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_7]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_7]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_411] = [__v_6]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_6]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_412: usize = 2; -const IN_412: usize = 2; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_415: usize = 2; +const IN_415: usize = 2; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], ExecError> { +) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37091,94 +37494,94 @@ fn aiur_fn_412( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_6]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_8]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_8]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_8]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_8]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37186,31 +37589,31 @@ fn aiur_fn_412( } }, 8u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_6]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_6]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_413: usize = 2; -const IN_413: usize = 2; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_416: usize = 2; +const IN_416: usize = 2; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37221,8 +37624,8 @@ fn aiur_fn_413( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_5]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_5]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -37231,15 +37634,15 @@ fn aiur_fn_413( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_6]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_6]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_6]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_6]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37251,15 +37654,15 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 2; -const IN_414: usize = 2; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_417: usize = 2; +const IN_417: usize = 2; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], ExecError> { +) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37270,80 +37673,80 @@ fn aiur_fn_414( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_0]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_0]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_0]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_0]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_0]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_11]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_11]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_415: usize = 2; -const IN_415: usize = 2; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_418: usize = 2; +const IN_418: usize = 2; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], ExecError> { +) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_5]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_5]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_416: usize = 2; -const IN_416: usize = 2; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_419: usize = 2; +const IN_419: usize = 2; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37354,57 +37757,57 @@ fn aiur_fn_416( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_0]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_0]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_0]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_0]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_0]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_11]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_11]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_417: usize = 3; -const IN_417: usize = 3; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_420: usize = 3; +const IN_420: usize = 3; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37416,104 +37819,104 @@ fn aiur_fn_417( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_10]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_10]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_14]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_14]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_18]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_18]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_16]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_16]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_9]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_9]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_7]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_7]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_7]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 6; -const IN_418: usize = 6; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_421: usize = 6; +const IN_421: usize = 6; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], ExecError> { +) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37521,9 +37924,9 @@ fn aiur_fn_418( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -37533,7 +37936,7 @@ fn aiur_fn_418( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -37551,50 +37954,50 @@ fn aiur_fn_418( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_28]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_28]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_26]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_26]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_13]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_13]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_419: usize = 5; -const IN_419: usize = 5; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_422: usize = 5; +const IN_422: usize = 5; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -37611,48 +38014,48 @@ fn aiur_fn_419( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_21]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_21]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_21]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_21]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_18]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_18]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_420: usize = 2; -const IN_420: usize = 2; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_423: usize = 2; +const IN_423: usize = 2; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], ExecError> { +) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37663,80 +38066,80 @@ fn aiur_fn_420( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_0]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_0]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_0]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_0]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_0]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_11]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_11]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 2; -const IN_421: usize = 2; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_424: usize = 2; +const IN_424: usize = 2; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], ExecError> { +) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_5]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_5]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_422: usize = 3; -const IN_422: usize = 3; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_425: usize = 3; +const IN_425: usize = 3; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], ExecError> { +) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37748,68 +38151,68 @@ fn aiur_fn_422( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_10]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_10]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_9]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_9]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 3; -const IN_423: usize = 3; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_426: usize = 3; +const IN_426: usize = 3; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], ExecError> { +) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37817,78 +38220,78 @@ fn aiur_fn_423( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_10]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_10]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_14]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_14]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_12]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_12]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 5; -const IN_424: usize = 5; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_427: usize = 5; +const IN_427: usize = 5; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], ExecError> { +) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_11]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37899,7 +38302,7 @@ fn aiur_fn_424( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -37917,21 +38320,21 @@ fn aiur_fn_424( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_30]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_30]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_30]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_30]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37939,10 +38342,10 @@ fn aiur_fn_424( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_17]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_17]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37951,32 +38354,32 @@ fn aiur_fn_424( }) } -const INPUT_SIZE_425: usize = 5; -const IN_425: usize = 5; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_428: usize = 5; +const IN_428: usize = 5; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], ExecError> { +) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -37992,7 +38395,7 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -38003,19 +38406,19 @@ fn aiur_fn_425( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_8]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_8]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_7]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38032,43 +38435,43 @@ fn aiur_fn_425( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_23]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_23]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_23]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_23]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38079,10 +38482,10 @@ fn aiur_fn_425( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -38097,46 +38500,46 @@ fn aiur_fn_425( let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_425] = [__v_25]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_25]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_29]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_29]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_425] = [__v_28]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_28]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_31]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_31]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_425] = [__v_28]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_28]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38144,10 +38547,10 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_29]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_29]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38155,10 +38558,10 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_21]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_21]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38167,40 +38570,40 @@ fn aiur_fn_425( }) } -const INPUT_SIZE_426: usize = 2; -const IN_426: usize = 2; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_429: usize = 2; +const IN_429: usize = 2; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], ExecError> { +) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_6]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_6]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_427: usize = 12; -const IN_427: usize = 12; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_430: usize = 12; +const IN_430: usize = 12; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], ExecError> { +) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38216,43 +38619,43 @@ fn aiur_fn_427( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_1]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38262,15 +38665,15 @@ fn aiur_fn_427( }) } -const INPUT_SIZE_428: usize = 12; -const IN_428: usize = 12; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_431: usize = 12; +const IN_431: usize = 12; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], ExecError> { +) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38286,43 +38689,43 @@ fn aiur_fn_428( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_2]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38332,21 +38735,21 @@ fn aiur_fn_428( }) } -const INPUT_SIZE_429: usize = 2; -const IN_429: usize = 2; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_432: usize = 2; +const IN_432: usize = 2; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], ExecError> { +) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38355,15 +38758,15 @@ fn aiur_fn_429( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_12]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_12]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -38371,16 +38774,16 @@ fn aiur_fn_429( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38395,23 +38798,23 @@ fn aiur_fn_429( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_24]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_24]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38421,14 +38824,14 @@ fn aiur_fn_429( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -38438,10 +38841,10 @@ fn aiur_fn_429( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_19]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_19]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38454,67 +38857,67 @@ fn aiur_fn_429( 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_429] = [__v_13]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_13]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_429] = [__v_15]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_15]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_10]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_10]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38523,11 +38926,11 @@ fn aiur_fn_429( } }, 8u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38537,7 +38940,7 @@ fn aiur_fn_429( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38558,7 +38961,7 @@ fn aiur_fn_429( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -38579,15 +38982,15 @@ fn aiur_fn_429( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_47]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_47]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38612,15 +39015,15 @@ fn aiur_fn_429( }) } -const INPUT_SIZE_430: usize = 2; -const IN_430: usize = 2; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_433: usize = 2; +const IN_433: usize = 2; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], ExecError> { +) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38631,15 +39034,15 @@ fn aiur_fn_430( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_10]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_10]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -38647,16 +39050,16 @@ fn aiur_fn_430( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_12]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -38671,23 +39074,23 @@ fn aiur_fn_430( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_22]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_22]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -38697,14 +39100,14 @@ fn aiur_fn_430( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_12]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -38714,10 +39117,10 @@ fn aiur_fn_430( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_17]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_17]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38730,67 +39133,67 @@ fn aiur_fn_430( 4u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_430] = [__v_11]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_11]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_430] = [__v_13]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_13]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_8]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_8]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_12]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_12]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38799,11 +39202,11 @@ fn aiur_fn_430( } }, 8u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38813,7 +39216,7 @@ fn aiur_fn_430( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -38834,7 +39237,7 @@ fn aiur_fn_430( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; @@ -38855,15 +39258,15 @@ fn aiur_fn_430( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_45]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_45]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38888,19 +39291,19 @@ fn aiur_fn_430( }) } -const INPUT_SIZE_431: usize = 2; -const IN_431: usize = 2; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_434: usize = 2; +const IN_434: usize = 2; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], ExecError> { +) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -38909,12 +39312,12 @@ fn aiur_fn_431( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_431] = [__v_4]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_4]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __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]; @@ -38923,8 +39326,8 @@ fn aiur_fn_431( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_431] = [__v_9]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_9]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38936,23 +39339,23 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 3; -const IN_432: usize = 3; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_435: usize = 3; +const IN_435: usize = 3; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: [G; IN_435], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_432] = [__v_0]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_0]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38970,14 +39373,14 @@ fn aiur_fn_432( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_14]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38994,15 +39397,15 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 5; -const IN_433: usize = 5; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_436: usize = 5; +const IN_436: usize = 5; +const OUT_436: usize = 1; +fn aiur_fn_436( + inp: [G; IN_436], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39019,22 +39422,22 @@ fn aiur_fn_433( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_433] = [__v_6]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_6]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_16]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_16]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39046,15 +39449,15 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 2; -const IN_434: usize = 2; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_437: usize = 2; +const IN_437: usize = 2; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: [G; IN_437], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39071,14 +39474,14 @@ fn aiur_fn_434( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_8]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_8]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39091,25 +39494,25 @@ fn aiur_fn_434( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_8]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_9]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_9]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39126,15 +39529,15 @@ fn aiur_fn_434( }) } -const INPUT_SIZE_435: usize = 3; -const IN_435: usize = 3; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_438: usize = 3; +const IN_438: usize = 3; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: [G; IN_438], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39143,33 +39546,33 @@ fn aiur_fn_435( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_435] = [__v_4]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_4]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_10]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_10]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_7]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_7]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39178,73 +39581,73 @@ fn aiur_fn_435( }) } -const INPUT_SIZE_436: usize = 4; -const IN_436: usize = 4; -const OUT_436: usize = 1; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_439: usize = 4; +const IN_439: usize = 4; +const OUT_439: usize = 1; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_12]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_12]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_18]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_18]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_437: usize = 3; -const IN_437: usize = 3; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_437], +const INPUT_SIZE_440: usize = 3; +const IN_440: usize = 3; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: [G; IN_440], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], ExecError> { +) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39252,73 +39655,73 @@ fn aiur_fn_437( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_4]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_4]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_4]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_4]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_438: usize = 3; -const IN_438: usize = 3; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_441: usize = 3; +const IN_441: usize = 3; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_438], ExecError> { +) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_438] = [__v_4]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_4]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_4]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_4]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_439: usize = 3; -const IN_439: usize = 3; -const OUT_439: usize = 1; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_442: usize = 3; +const IN_442: usize = 3; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], ExecError> { +) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39338,33 +39741,33 @@ fn aiur_fn_439( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_17]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_17]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_20]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_20]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39373,39 +39776,39 @@ fn aiur_fn_439( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_16]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_16]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_15]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_15]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_11]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_11]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 3; -const IN_440: usize = 3; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_443: usize = 3; +const IN_443: usize = 3; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], ExecError> { +) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39423,14 +39826,14 @@ fn aiur_fn_440( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_9]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_9]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39443,25 +39846,25 @@ fn aiur_fn_440( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_9]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_10]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_10]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_10]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_10]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39478,15 +39881,15 @@ fn aiur_fn_440( }) } -const INPUT_SIZE_441: usize = 1; -const IN_441: usize = 1; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_444: usize = 1; +const IN_444: usize = 1; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], ExecError> { +) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39498,48 +39901,48 @@ fn aiur_fn_441( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_5]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_5]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_6]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_6]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_5]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_442: usize = 1; -const IN_442: usize = 1; -const OUT_442: usize = 3; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_445: usize = 1; +const IN_445: usize = 1; +const OUT_445: usize = 3; +fn aiur_fn_445( + inp: [G; IN_445], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], ExecError> { +) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39555,10 +39958,10 @@ fn aiur_fn_442( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_5, __v_9, __v_3]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5, __v_9, __v_3]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39566,8 +39969,8 @@ fn aiur_fn_442( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39580,21 +39983,21 @@ fn aiur_fn_442( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_14, __v_12, __v_15]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39602,8 +40005,8 @@ fn aiur_fn_442( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39616,7 +40019,7 @@ fn aiur_fn_442( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -39631,23 +40034,23 @@ fn aiur_fn_442( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_22, __v_20, __v_23]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_442] = [__v_22, __v_7, __v_17]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_22, __v_7, __v_17]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39657,8 +40060,8 @@ fn aiur_fn_442( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39668,8 +40071,8 @@ fn aiur_fn_442( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39679,8 +40082,8 @@ fn aiur_fn_442( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_15, __v_0, __v_18]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_15, __v_0, __v_18]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39690,8 +40093,8 @@ fn aiur_fn_442( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_13, __v_0, __v_16]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_13, __v_0, __v_16]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39701,8 +40104,8 @@ fn aiur_fn_442( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_9, __v_0, __v_12]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_9, __v_0, __v_12]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39712,46 +40115,46 @@ fn aiur_fn_442( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; -const OUT_443: usize = 2; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 2; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], ExecError> { +) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_443] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -39760,27 +40163,27 @@ fn aiur_fn_443( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39791,48 +40194,48 @@ fn aiur_fn_443( }) } -const INPUT_SIZE_444: usize = 3; -const IN_444: usize = 3; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 1; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], ExecError> { +) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_444] = [__v_4]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_4]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_4]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_4]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_445: usize = 3; -const IN_445: usize = 3; -const OUT_445: usize = 1; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_448: usize = 3; +const IN_448: usize = 3; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], ExecError> { +) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39846,48 +40249,48 @@ fn aiur_fn_445( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_9]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_9]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_445] = [__v_7]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_7]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_445] = [__v_7]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_7]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_446: usize = 3; -const IN_446: usize = 3; -const OUT_446: usize = 1; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_449: usize = 3; +const IN_449: usize = 3; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], ExecError> { +) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -39895,7 +40298,7 @@ fn aiur_fn_446( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -39905,71 +40308,71 @@ fn aiur_fn_446( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_446] = [__v_5]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_5]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_5]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_5]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_447: usize = 3; -const IN_447: usize = 3; -const OUT_447: usize = 1; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_450: usize = 3; +const IN_450: usize = 3; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_6]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_6]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_7]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_7]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_8]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_8]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_447] = [__v_8]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_8]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39980,58 +40383,58 @@ fn aiur_fn_447( }) } -const INPUT_SIZE_448: usize = 5; -const IN_448: usize = 5; -const OUT_448: usize = 1; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_451: usize = 5; +const IN_451: usize = 5; +const OUT_451: usize = 1; +fn aiur_fn_451( + inp: [G; IN_451], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_448] = [__v_8]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_8]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_448] = [__v_9]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_9]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_448] = [__v_10]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_10]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_448] = [__v_10]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_10]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40042,15 +40445,15 @@ fn aiur_fn_448( }) } -const INPUT_SIZE_449: usize = 3; -const IN_449: usize = 3; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40069,16 +40472,16 @@ fn aiur_fn_449( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40091,30 +40494,30 @@ fn aiur_fn_449( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_14]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_14]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_12]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_12]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40127,53 +40530,53 @@ fn aiur_fn_449( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_14]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_14]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_12]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_12]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_7]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_7]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 5; -const IN_450: usize = 5; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_453: usize = 5; +const IN_453: usize = 5; +const OUT_453: usize = 1; +fn aiur_fn_453( + inp: [G; IN_453], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40184,78 +40587,78 @@ fn aiur_fn_450( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_6]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_6]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_7]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_8]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_8]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_9]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_9]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_10]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_10]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_450] = [__v_11]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_11]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_16]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_16]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_450] = [__v_16]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_16]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40274,15 +40677,15 @@ fn aiur_fn_450( }) } -const INPUT_SIZE_451: usize = 5; -const IN_451: usize = 5; -const OUT_451: usize = 1; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_454: usize = 5; +const IN_454: usize = 5; +const OUT_454: usize = 1; +fn aiur_fn_454( + inp: [G; IN_454], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40290,31 +40693,31 @@ fn aiur_fn_451( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_8]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_8]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_9]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_9]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_451] = [__v_9]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_9]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40323,38 +40726,38 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 3; -const IN_452: usize = 3; -const OUT_452: usize = 1; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_455: usize = 3; +const IN_455: usize = 3; +const OUT_455: usize = 1; +fn aiur_fn_455( + inp: [G; IN_455], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_8]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_8]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { @@ -40383,40 +40786,40 @@ fn aiur_fn_452( let __v_25: G = (__v_19 * __v_24); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_26]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_26]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_26]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_26]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_19]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_19]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_15]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_11]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40425,45 +40828,45 @@ fn aiur_fn_452( }) } -const INPUT_SIZE_453: usize = 3; -const IN_453: usize = 3; -const OUT_453: usize = 1; -fn aiur_fn_453( - inp: [G; IN_453], +const INPUT_SIZE_456: usize = 3; +const IN_456: usize = 3; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_453], ExecError> { +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(8); - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_6]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_6]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_7]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_7]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40472,15 +40875,15 @@ fn aiur_fn_453( }) } -const INPUT_SIZE_454: usize = 3; -const IN_454: usize = 3; -const OUT_454: usize = 1; -fn aiur_fn_454( - inp: [G; IN_454], +const INPUT_SIZE_457: usize = 3; +const IN_457: usize = 3; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_454], ExecError> { +) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40499,51 +40902,51 @@ fn aiur_fn_454( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_12]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_12]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_454] = [__v_11]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_11]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_454] = [__v_7]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_7]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_455: usize = 4; -const IN_455: usize = 4; -const OUT_455: usize = 2; -fn aiur_fn_455( - inp: [G; IN_455], +const INPUT_SIZE_458: usize = 4; +const IN_458: usize = 4; +const OUT_458: usize = 2; +fn aiur_fn_458( + inp: [G; IN_458], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_455], ExecError> { +) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40553,8 +40956,8 @@ fn aiur_fn_455( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_455] = [__v_5, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_5, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -40576,24 +40979,24 @@ fn aiur_fn_455( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40606,18 +41009,18 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40634,28 +41037,28 @@ fn aiur_fn_455( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40668,32 +41071,32 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40706,34 +41109,34 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40746,34 +41149,34 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40786,18 +41189,18 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40817,47 +41220,47 @@ fn aiur_fn_455( let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_15, __v_2]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_455] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40866,15 +41269,15 @@ fn aiur_fn_455( }) } -const INPUT_SIZE_456: usize = 4; -const IN_456: usize = 4; -const OUT_456: usize = 2; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_459: usize = 4; +const IN_459: usize = 4; +const OUT_459: usize = 2; +fn aiur_fn_459( + inp: [G; IN_459], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { +) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40884,54 +41287,54 @@ fn aiur_fn_456( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_9, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_9, __v_5]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_456] = [__v_10, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_10, __v_5]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_15, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_5]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_456] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40944,96 +41347,96 @@ fn aiur_fn_456( }) } -const INPUT_SIZE_457: usize = 3; -const IN_457: usize = 3; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_460: usize = 3; +const IN_460: usize = 3; +const OUT_460: usize = 1; +fn aiur_fn_460( + inp: [G; IN_460], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_6]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_6]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_7]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_8]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_8]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_9]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_9]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_10]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_10]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_457] = [__v_11]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_11]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_13]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_13]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_13]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_13]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41052,20 +41455,20 @@ fn aiur_fn_457( }) } -const INPUT_SIZE_458: usize = 3; -const IN_458: usize = 3; -const OUT_458: usize = 1; -fn aiur_fn_458( - inp: [G; IN_458], +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: [G; IN_461], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_458], ExecError> { +) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41075,7 +41478,7 @@ fn aiur_fn_458( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -41092,13 +41495,13 @@ fn aiur_fn_458( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -41123,42 +41526,42 @@ fn aiur_fn_458( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_43]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_43]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_45]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_45]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_48]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_48]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_49]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_49]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41169,47 +41572,47 @@ fn aiur_fn_458( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_38]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_38]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_25]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_25]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_22]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_22]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_9]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_9]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_459: usize = 7; -const IN_459: usize = 7; -const OUT_459: usize = 1; -fn aiur_fn_459( - inp: [G; IN_459], +const INPUT_SIZE_462: usize = 7; +const IN_462: usize = 7; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_459], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41222,32 +41625,32 @@ fn aiur_fn_459( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_8]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_8]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_13]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_13]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_15]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_15]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41256,19 +41659,19 @@ fn aiur_fn_459( }) } -const INPUT_SIZE_460: usize = 2; -const IN_460: usize = 2; -const OUT_460: usize = 1; -fn aiur_fn_460( - inp: [G; IN_460], +const INPUT_SIZE_463: usize = 2; +const IN_463: usize = 2; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_460], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -41291,25 +41694,25 @@ fn aiur_fn_460( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_460] = [__v_25]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_25]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_461: usize = 3; -const IN_461: usize = 3; -const OUT_461: usize = 1; -fn aiur_fn_461( - inp: [G; IN_461], +const INPUT_SIZE_464: usize = 3; +const IN_464: usize = 3; +const OUT_464: usize = 1; +fn aiur_fn_464( + inp: [G; IN_464], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_461], ExecError> { +) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41329,15 +41732,15 @@ fn aiur_fn_461( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_11]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_11]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41350,16 +41753,16 @@ fn aiur_fn_461( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_11]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_11]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41368,57 +41771,57 @@ fn aiur_fn_461( }) } -const INPUT_SIZE_462: usize = 3; -const IN_462: usize = 3; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_465: usize = 3; +const IN_465: usize = 3; +const OUT_465: usize = 1; +fn aiur_fn_465( + inp: [G; IN_465], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_6]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_6]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_7]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_7]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_463: usize = 1; -const IN_463: usize = 1; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_466: usize = 1; +const IN_466: usize = 1; +const OUT_466: usize = 1; +fn aiur_fn_466( + inp: [G; IN_466], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41428,7 +41831,7 @@ fn aiur_fn_463( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41452,7 +41855,7 @@ fn aiur_fn_463( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -41472,114 +41875,114 @@ fn aiur_fn_463( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_36]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_36]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_36]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_22]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_22]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_20]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_20]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_20]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_20]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_7]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_7]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_464: usize = 3; -const IN_464: usize = 3; -const OUT_464: usize = 1; -fn aiur_fn_464( - inp: [G; IN_464], +const INPUT_SIZE_467: usize = 3; +const IN_467: usize = 3; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_464], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_464] = [__v_5]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_5]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_6]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_6]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_465: usize = 4; -const IN_465: usize = 4; -const OUT_465: usize = 1; -fn aiur_fn_465( - inp: [G; IN_465], +const INPUT_SIZE_468: usize = 4; +const IN_468: usize = 4; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_465], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -41588,19 +41991,19 @@ fn aiur_fn_465( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -41611,39 +42014,39 @@ fn aiur_fn_465( let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_23]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_23]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_10]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_10]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_466: usize = 2; -const IN_466: usize = 2; -const OUT_466: usize = 1; -fn aiur_fn_466( - inp: [G; IN_466], +const INPUT_SIZE_469: usize = 2; +const IN_469: usize = 2; +const OUT_469: usize = 1; +fn aiur_fn_469( + inp: [G; IN_469], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_466], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -41655,52 +42058,52 @@ fn aiur_fn_466( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_466] = [__v_11]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_8]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_8]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_467: usize = 3; -const IN_467: usize = 3; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_470: usize = 3; +const IN_470: usize = 3; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: [G; IN_470], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_467] = [__v_3]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_3]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_468: usize = 3; -const IN_468: usize = 3; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_471: usize = 3; +const IN_471: usize = 3; +const OUT_471: usize = 1; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41723,22 +42126,22 @@ fn aiur_fn_468( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41751,16 +42154,16 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41777,26 +42180,26 @@ fn aiur_fn_468( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41809,31 +42212,31 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41841,10 +42244,10 @@ fn aiur_fn_468( } }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41857,31 +42260,31 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_14]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_14]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41894,38 +42297,38 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_14]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_14]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_7]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_7]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -41936,28 +42339,28 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41979,32 +42382,32 @@ fn aiur_fn_468( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_13]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_12]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_11]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42016,15 +42419,15 @@ fn aiur_fn_468( }) } -const INPUT_SIZE_469: usize = 4; -const IN_469: usize = 4; -const OUT_469: usize = 3; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_472: usize = 4; +const IN_472: usize = 4; +const OUT_472: usize = 3; +fn aiur_fn_472( + inp: [G; IN_472], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42033,8 +42436,8 @@ fn aiur_fn_469( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_4, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_4, __v_0, __v_1]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -42042,46 +42445,46 @@ fn aiur_fn_469( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_469] = [__v_5, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_5, __v_0, __v_1]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_469] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42089,21 +42492,21 @@ fn aiur_fn_469( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42118,15 +42521,15 @@ fn aiur_fn_469( }) } -const INPUT_SIZE_470: usize = 12; -const IN_470: usize = 12; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_473: usize = 12; +const IN_473: usize = 12; +const OUT_473: usize = 1; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42142,29 +42545,29 @@ fn aiur_fn_470( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_470] = [__v_5]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_5]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_470] = [__v_12]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_12]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_471: usize = 6; -const IN_471: usize = 6; -const OUT_471: usize = 3; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_474: usize = 6; +const IN_474: usize = 6; +const OUT_474: usize = 3; +fn aiur_fn_474( + inp: [G; IN_474], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42172,7 +42575,7 @@ fn aiur_fn_471( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -42187,7 +42590,7 @@ fn aiur_fn_471( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -42202,26 +42605,26 @@ fn aiur_fn_471( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_34, __v_2, __v_3]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_34, __v_2, __v_3]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42229,49 +42632,49 @@ fn aiur_fn_471( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; - let __ret: [G; OUT_471] = [__v_37, __v_38, __v_39]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_37, __v_38, __v_39]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42284,176 +42687,176 @@ fn aiur_fn_471( }) } -const INPUT_SIZE_472: usize = 4; -const IN_472: usize = 4; -const OUT_472: usize = 3; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_475: usize = 4; +const IN_475: usize = 4; +const OUT_475: usize = 3; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], ExecError> { +) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_473: usize = 4; -const IN_473: usize = 4; -const OUT_473: usize = 3; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_476: usize = 4; +const IN_476: usize = 4; +const OUT_476: usize = 3; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], ExecError> { +) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_473] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 4; -const IN_474: usize = 4; -const OUT_474: usize = 3; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_477: usize = 4; +const IN_477: usize = 4; +const OUT_477: usize = 3; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], ExecError> { +) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_474] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_474] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_475: usize = 5; -const IN_475: usize = 5; -const OUT_475: usize = 3; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_478: usize = 5; +const IN_478: usize = 5; +const OUT_478: usize = 3; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], ExecError> { +) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42468,35 +42871,35 @@ fn aiur_fn_475( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_475] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_475] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42507,38 +42910,38 @@ fn aiur_fn_475( }) } -const INPUT_SIZE_476: usize = 5; -const IN_476: usize = 5; -const OUT_476: usize = 3; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_479: usize = 5; +const IN_479: usize = 5; +const OUT_479: usize = 3; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], ExecError> { +) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42553,35 +42956,35 @@ fn aiur_fn_476( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_476] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_476] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_476] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42592,24 +42995,24 @@ fn aiur_fn_476( }) } -const INPUT_SIZE_477: usize = 4; -const IN_477: usize = 4; -const OUT_477: usize = 3; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_480: usize = 4; +const IN_480: usize = 4; +const OUT_480: usize = 3; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], ExecError> { +) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -42618,23 +43021,23 @@ fn aiur_fn_477( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42644,18 +43047,18 @@ fn aiur_fn_477( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42664,15 +43067,15 @@ fn aiur_fn_477( }) } -const INPUT_SIZE_478: usize = 12; -const IN_478: usize = 12; -const OUT_478: usize = 1; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_481: usize = 12; +const IN_481: usize = 12; +const OUT_481: usize = 1; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], ExecError> { +) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42689,39 +43092,39 @@ fn aiur_fn_478( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_479: usize = 2; -const IN_479: usize = 2; -const OUT_479: usize = 2; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_482: usize = 2; +const IN_482: usize = 2; +const OUT_482: usize = 2; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], ExecError> { +) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42731,9 +43134,9 @@ fn aiur_fn_479( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42743,7 +43146,7 @@ fn aiur_fn_479( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -42751,50 +43154,50 @@ fn aiur_fn_479( let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_479] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_17, __v_0]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_17, __v_0]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_479] = [__v_15, __v_8]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_15, __v_8]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_8, __v_0]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_8, __v_0]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_480: usize = 1; -const IN_480: usize = 1; -const OUT_480: usize = 2; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_483: usize = 1; +const IN_483: usize = 1; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], ExecError> { +) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42804,7 +43207,7 @@ fn aiur_fn_480( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42821,79 +43224,79 @@ fn aiur_fn_480( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_480] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_480] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_20, __v_0]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_20, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_7, __v_0]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_7, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_481: usize = 3; -const IN_481: usize = 3; -const OUT_481: usize = 1; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_484: usize = 3; +const IN_484: usize = 3; +const OUT_484: usize = 1; +fn aiur_fn_484( + inp: [G; IN_484], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], ExecError> { +) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_7]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_7]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_7]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_7]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42908,7 +43311,7 @@ fn aiur_fn_481( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -42923,27 +43326,27 @@ fn aiur_fn_481( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_37]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_37]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42951,16 +43354,16 @@ fn aiur_fn_481( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_37]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_37]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42976,18 +43379,18 @@ fn aiur_fn_481( }) } -const INPUT_SIZE_482: usize = 1; -const IN_482: usize = 1; -const OUT_482: usize = 2; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_485: usize = 1; +const IN_485: usize = 1; +const OUT_485: usize = 2; +fn aiur_fn_485( + inp: [G; IN_485], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], ExecError> { +) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42998,8 +43401,8 @@ fn aiur_fn_482( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43037,23 +43440,23 @@ fn aiur_fn_482( let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_39, __v_40]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_39, __v_40]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_483: usize = 14; -const IN_483: usize = 14; -const OUT_483: usize = 2; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_486: usize = 14; +const IN_486: usize = 14; +const OUT_486: usize = 2; +fn aiur_fn_486( + inp: [G; IN_486], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_483], ExecError> { +) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43071,154 +43474,154 @@ fn aiur_fn_483( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_14, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_14, __v_0]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_484: usize = 2; -const IN_484: usize = 2; -const OUT_484: usize = 1; -fn aiur_fn_484( - inp: [G; IN_484], +const INPUT_SIZE_487: usize = 2; +const IN_487: usize = 2; +const OUT_487: usize = 1; +fn aiur_fn_487( + inp: [G; IN_487], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_484], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_6]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_6]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_3]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_3]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_485: usize = 3; -const IN_485: usize = 3; -const OUT_485: usize = 1; -fn aiur_fn_485( - inp: [G; IN_485], +const INPUT_SIZE_488: usize = 3; +const IN_488: usize = 3; +const OUT_488: usize = 1; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_485], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_485] = [__v_8]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_8]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_485] = [__v_14]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_14]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_486: usize = 2; -const IN_486: usize = 2; -const OUT_486: usize = 1; -fn aiur_fn_486( - inp: [G; IN_486], +const INPUT_SIZE_489: usize = 2; +const IN_489: usize = 2; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_486], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43229,15 +43632,15 @@ fn aiur_fn_486( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_10]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_10]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -43245,16 +43648,16 @@ fn aiur_fn_486( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_12]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -43269,91 +43672,91 @@ fn aiur_fn_486( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_22]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_22]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_12]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_12]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_486] = [__v_13]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_13]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_9]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_9]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_6]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_6]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_6]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_6]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43363,15 +43766,15 @@ fn aiur_fn_486( }) } -const INPUT_SIZE_487: usize = 4; -const IN_487: usize = 4; -const OUT_487: usize = 1; -fn aiur_fn_487( - inp: [G; IN_487], +const INPUT_SIZE_490: usize = 4; +const IN_490: usize = 4; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { +) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43383,20 +43786,20 @@ fn aiur_fn_487( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_487] = [__v_0]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_0]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_9]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_9]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43409,7 +43812,7 @@ fn aiur_fn_487( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43417,24 +43820,24 @@ fn aiur_fn_487( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_15]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_15]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43442,14 +43845,14 @@ fn aiur_fn_487( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -43458,16 +43861,16 @@ fn aiur_fn_487( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_23]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_23]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43484,43 +43887,43 @@ fn aiur_fn_487( }) } -const INPUT_SIZE_488: usize = 2; -const IN_488: usize = 2; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_491: usize = 2; +const IN_491: usize = 2; +const OUT_491: usize = 1; +fn aiur_fn_491( + inp: [G; IN_491], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_488] = [__v_8]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_8]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_488] = [__v_8]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_8]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43530,23 +43933,23 @@ fn aiur_fn_488( }) } -const INPUT_SIZE_489: usize = 4; -const IN_489: usize = 4; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_492: usize = 4; +const IN_492: usize = 4; +const OUT_492: usize = 1; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], ExecError> { +) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -43558,10 +43961,10 @@ fn aiur_fn_489( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_13]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = [__v_13]; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43571,29 +43974,29 @@ fn aiur_fn_489( }) } -const INPUT_SIZE_490: usize = 3; -const IN_490: usize = 3; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_493: usize = 3; +const IN_493: usize = 3; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_3]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_3]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -43606,15 +44009,15 @@ fn aiur_fn_490( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_12]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_12]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_490] = [__v_3]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_3]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43623,54 +44026,54 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 3; -const IN_491: usize = 3; -const OUT_491: usize = 0; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_494: usize = 3; +const IN_494: usize = 3; +const OUT_494: usize = 0; +fn aiur_fn_494( + inp: [G; IN_494], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], ExecError> { +) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_491] = []; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = []; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } - let __ret: [G; OUT_491] = []; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = []; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_492: usize = 4; -const IN_492: usize = 4; -const OUT_492: usize = 0; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_495: usize = 4; +const IN_495: usize = 4; +const OUT_495: usize = 0; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], ExecError> { +) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43678,33 +44081,33 @@ fn aiur_fn_492( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = []; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = []; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } - let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = []; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43713,15 +44116,15 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 7; -const IN_493: usize = 7; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_496: usize = 7; +const IN_496: usize = 7; +const OUT_496: usize = 1; +fn aiur_fn_496( + inp: [G; IN_496], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], ExecError> { +) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43740,24 +44143,24 @@ fn aiur_fn_493( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_493] = [__v_8]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_496] = [__v_8]; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_18]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_496] = [__v_18]; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43769,25 +44172,25 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 4; -const IN_494: usize = 4; -const OUT_494: usize = 1; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_497: usize = 4; +const IN_497: usize = 4; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], ExecError> { +) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43797,7 +44200,7 @@ fn aiur_fn_494( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -43818,7 +44221,7 @@ fn aiur_fn_494( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -43839,18 +44242,18 @@ fn aiur_fn_494( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_45]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_497] = [__v_45]; + if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43870,21 +44273,21 @@ fn aiur_fn_494( }) } -const INPUT_SIZE_495: usize = 2; -const IN_495: usize = 2; -const OUT_495: usize = 1; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], ExecError> { +) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -43893,8 +44296,8 @@ fn aiur_fn_495( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_495] = [__v_5]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_498] = [__v_5]; + if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43904,175 +44307,28 @@ fn aiur_fn_495( }) } -const INPUT_SIZE_496: usize = 3; -const IN_496: usize = 3; -const OUT_496: usize = 0; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_499: usize = 3; +const IN_499: usize = 3; +const OUT_499: usize = 0; +fn aiur_fn_499( + inp: [G; IN_499], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], ExecError> { +) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } - let __ret: [G; OUT_496] = []; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_497: usize = 0; -const IN_497: usize = 0; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_497], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(69); - let __v_1: G = G::from_u64(96); - let __v_2: G = G::from_u64(197); - let __v_3: G = G::from_u64(241); - let __v_4: G = G::from_u64(33); - let __v_5: G = G::from_u64(165); - let __v_6: G = G::from_u64(66); - let __v_7: G = G::from_u64(242); - let __v_8: G = G::from_u64(194); - let __v_9: G = G::from_u64(51); - let __v_10: G = G::from_u64(98); - let __v_11: G = G::from_u64(111); - let __v_12: G = G::from_u64(78); - let __v_13: G = G::from_u64(246); - let __v_14: G = G::from_u64(253); - let __v_15: G = G::from_u64(216); - let __v_16: G = G::from_u64(243); - let __v_17: G = G::from_u64(110); - let __v_18: G = G::from_u64(190); - let __v_19: G = G::from_u64(151); - let __v_20: G = G::from_u64(201); - let __v_21: G = G::from_u64(72); - let __v_22: G = G::from_u64(173); - let __v_23: G = G::from_u64(234); - let __v_24: G = G::from_u64(238); - let __v_25: G = G::from_u64(40); - let __v_26: G = G::from_u64(61); - let __v_27: G = G::from_u64(158); - let __v_28: G = G::from_u64(212); - let __v_29: G = G::from_u64(87); - let __v_30: G = G::from_u64(47); - let __v_31: G = G::from_u64(219); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_497] = [__v_32]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_498: usize = 0; -const IN_498: usize = 0; -const OUT_498: usize = 1; -fn aiur_fn_498( - inp: [G; IN_498], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_498], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(163); - let __v_1: G = G::from_u64(245); - let __v_2: G = G::from_u64(168); - let __v_3: G = G::from_u64(13); - let __v_4: G = G::from_u64(26); - let __v_5: G = G::from_u64(140); - let __v_6: G = G::from_u64(201); - let __v_7: G = G::from_u64(144); - let __v_8: G = G::from_u64(99); - let __v_9: G = G::from_u64(157); - let __v_10: G = G::from_u64(6); - let __v_11: G = G::from_u64(190); - let __v_12: G = G::from_u64(152); - let __v_13: G = G::from_u64(188); - let __v_14: G = G::from_u64(194); - let __v_15: G = G::from_u64(178); - let __v_16: G = G::from_u64(64); - let __v_17: G = G::from_u64(247); - let __v_18: G = G::from_u64(147); - let __v_19: G = G::from_u64(164); - let __v_20: G = G::from_u64(173); - let __v_21: G = G::from_u64(186); - let __v_22: G = G::from_u64(155); - let __v_23: G = G::from_u64(0); - let __v_24: G = G::from_u64(39); - let __v_25: G = G::from_u64(18); - let __v_26: G = G::from_u64(184); - let __v_27: G = G::from_u64(4); - let __v_28: G = G::from_u64(166); - let __v_29: G = G::from_u64(254); - let __v_30: G = G::from_u64(51); - let __v_31: G = G::from_u64(118); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_498] = [__v_32]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_499: usize = 0; -const IN_499: usize = 0; -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 = G::from_u64(46); - let __v_1: G = G::from_u64(163); - let __v_2: G = G::from_u64(101); - let __v_3: G = G::from_u64(57); - let __v_4: G = G::from_u64(172); - let __v_5: G = G::from_u64(26); - let __v_6: G = G::from_u64(142); - let __v_7: G = G::from_u64(0); - let __v_8: G = G::from_u64(34); - let __v_9: G = G::from_u64(169); - let __v_10: G = G::from_u64(13); - let __v_11: G = G::from_u64(139); - let __v_12: G = G::from_u64(112); - let __v_13: G = G::from_u64(221); - let __v_14: G = G::from_u64(182); - let __v_15: G = G::from_u64(244); - let __v_16: G = G::from_u64(219); - let __v_17: G = G::from_u64(70); - let __v_18: G = G::from_u64(176); - let __v_19: G = G::from_u64(206); - let __v_20: G = G::from_u64(25); - let __v_21: G = G::from_u64(239); - let __v_22: G = G::from_u64(228); - let __v_23: G = G::from_u64(225); - let __v_24: G = G::from_u64(196); - let __v_25: G = G::from_u64(71); - let __v_26: G = G::from_u64(146); - let __v_27: G = G::from_u64(254); - let __v_28: G = G::from_u64(237); - let __v_29: G = G::from_u64(157); - let __v_30: G = G::from_u64(126); - let __v_31: G = G::from_u64(143); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_499] = [__v_32]; + let __ret: [G; OUT_499] = []; if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -44088,38 +44344,38 @@ fn aiur_fn_500( unconstrained: bool, ) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(15); - let __v_1: G = G::from_u64(158); - 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_0: G = G::from_u64(41); + let __v_1: G = G::from_u64(153); + let __v_2: G = G::from_u64(128); + let __v_3: G = G::from_u64(21); + let __v_4: G = G::from_u64(152); + let __v_5: G = G::from_u64(193); + let __v_6: G = G::from_u64(218); + let __v_7: G = G::from_u64(72); + let __v_8: G = G::from_u64(245); + let __v_9: G = G::from_u64(98); + let __v_10: G = G::from_u64(212); + let __v_11: G = G::from_u64(131); + let __v_12: G = G::from_u64(96); + let __v_13: G = G::from_u64(100); + let __v_14: G = G::from_u64(246); + let __v_15: G = G::from_u64(53); + let __v_16: G = G::from_u64(192); + let __v_17: G = G::from_u64(69); + let __v_18: G = G::from_u64(208); + let __v_19: G = G::from_u64(82); + let __v_20: G = G::from_u64(20); + let __v_21: G = G::from_u64(82); + let __v_22: G = G::from_u64(181); + let __v_23: G = G::from_u64(231); + let __v_24: G = G::from_u64(74); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(191); + let __v_27: G = G::from_u64(153); + let __v_28: G = G::from_u64(210); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(22); + let __v_31: G = G::from_u64(236); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_500] = [__v_32]; if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44137,38 +44393,38 @@ fn aiur_fn_501( unconstrained: bool, ) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(4); - let __v_1: G = G::from_u64(113); - 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_0: G = G::from_u64(27); + let __v_1: G = G::from_u64(172); + let __v_2: G = G::from_u64(4); + let __v_3: G = G::from_u64(23); + let __v_4: G = G::from_u64(86); + let __v_5: G = G::from_u64(237); + let __v_6: G = G::from_u64(34); + let __v_7: G = G::from_u64(215); + let __v_8: G = G::from_u64(59); + let __v_9: G = G::from_u64(188); + let __v_10: G = G::from_u64(172); + let __v_11: G = G::from_u64(132); + let __v_12: G = G::from_u64(154); + let __v_13: G = G::from_u64(148); + let __v_14: G = G::from_u64(242); + let __v_15: G = G::from_u64(70); + let __v_16: G = G::from_u64(238); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(150); + let __v_19: G = G::from_u64(153); + let __v_20: G = G::from_u64(159); + let __v_21: G = G::from_u64(175); + let __v_22: G = G::from_u64(53); + let __v_23: G = G::from_u64(25); + let __v_24: G = G::from_u64(64); + let __v_25: G = G::from_u64(70); + let __v_26: G = G::from_u64(141); + let __v_27: G = G::from_u64(150); + let __v_28: G = G::from_u64(41); + let __v_29: G = G::from_u64(112); + let __v_30: G = G::from_u64(202); + let __v_31: G = G::from_u64(42); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_501] = [__v_32]; if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44186,38 +44442,38 @@ fn aiur_fn_502( unconstrained: bool, ) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(4); - let __v_1: G = G::from_u64(42); - let __v_2: G = G::from_u64(154); - let __v_3: G = G::from_u64(209); - let __v_4: G = G::from_u64(72); - let __v_5: G = G::from_u64(158); - let __v_6: G = G::from_u64(118); - let __v_7: G = G::from_u64(159); - let __v_8: G = G::from_u64(210); - let __v_9: G = G::from_u64(149); - let __v_10: G = G::from_u64(213); - let __v_11: G = G::from_u64(140); - let __v_12: G = G::from_u64(182); - let __v_13: G = G::from_u64(74); - let __v_14: G = G::from_u64(116); - let __v_15: G = G::from_u64(5); - let __v_16: G = G::from_u64(232); - let __v_17: G = G::from_u64(111); - let __v_18: G = G::from_u64(120); - let __v_19: G = G::from_u64(129); - let __v_20: G = G::from_u64(181); - let __v_21: G = G::from_u64(231); - let __v_22: G = G::from_u64(194); - let __v_23: G = G::from_u64(45); - let __v_24: G = G::from_u64(119); - let __v_25: G = G::from_u64(223); - let __v_26: G = G::from_u64(72); - let __v_27: G = G::from_u64(105); - let __v_28: G = G::from_u64(21); - let __v_29: G = G::from_u64(213); - let __v_30: G = G::from_u64(142); - let __v_31: G = G::from_u64(179); + let __v_0: G = G::from_u64(18); + let __v_1: G = G::from_u64(243); + let __v_2: G = G::from_u64(134); + let __v_3: G = G::from_u64(244); + let __v_4: G = G::from_u64(134); + let __v_5: G = G::from_u64(145); + let __v_6: G = G::from_u64(59); + let __v_7: G = G::from_u64(17); + let __v_8: G = G::from_u64(181); + let __v_9: G = G::from_u64(71); + let __v_10: G = G::from_u64(60); + let __v_11: G = G::from_u64(178); + let __v_12: G = G::from_u64(83); + let __v_13: G = G::from_u64(131); + let __v_14: G = G::from_u64(48); + let __v_15: G = G::from_u64(213); + let __v_16: G = G::from_u64(31); + let __v_17: G = G::from_u64(37); + let __v_18: G = G::from_u64(174); + let __v_19: G = G::from_u64(236); + let __v_20: G = G::from_u64(127); + let __v_21: G = G::from_u64(45); + let __v_22: G = G::from_u64(125); + let __v_23: G = G::from_u64(107); + let __v_24: G = G::from_u64(150); + let __v_25: G = G::from_u64(144); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(41); + let __v_28: G = G::from_u64(199); + let __v_29: G = G::from_u64(139); + let __v_30: G = G::from_u64(105); + let __v_31: G = G::from_u64(103); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_502] = [__v_32]; if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44235,38 +44491,38 @@ fn aiur_fn_503( unconstrained: bool, ) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(125); - let __v_1: G = G::from_u64(175); - let __v_2: G = G::from_u64(170); - let __v_3: G = G::from_u64(21); - let __v_4: G = G::from_u64(30); - let __v_5: G = G::from_u64(217); - let __v_6: G = G::from_u64(11); - let __v_7: G = G::from_u64(10); - let __v_8: G = G::from_u64(178); - let __v_9: G = G::from_u64(127); - let __v_10: G = G::from_u64(2); - let __v_11: G = G::from_u64(121); - let __v_12: G = G::from_u64(185); - let __v_13: G = G::from_u64(56); - let __v_14: G = G::from_u64(58); - let __v_15: G = G::from_u64(184); - let __v_16: G = G::from_u64(171); - let __v_17: G = G::from_u64(232); - let __v_18: G = G::from_u64(96); - let __v_19: G = G::from_u64(44); - let __v_20: G = G::from_u64(102); - let __v_21: G = G::from_u64(53); - let __v_22: G = G::from_u64(202); - let __v_23: G = G::from_u64(25); - let __v_24: G = G::from_u64(31); - let __v_25: G = G::from_u64(40); - let __v_26: G = G::from_u64(203); - let __v_27: G = G::from_u64(183); - let __v_28: G = G::from_u64(171); - let __v_29: G = G::from_u64(166); - let __v_30: G = G::from_u64(175); - let __v_31: G = G::from_u64(221); + let __v_0: G = G::from_u64(123); + let __v_1: G = G::from_u64(63); + let __v_2: G = G::from_u64(106); + let __v_3: G = G::from_u64(110); + let __v_4: G = G::from_u64(235); + let __v_5: G = G::from_u64(243); + let __v_6: G = G::from_u64(42); + let __v_7: G = G::from_u64(157); + let __v_8: G = G::from_u64(90); + let __v_9: G = G::from_u64(84); + let __v_10: G = G::from_u64(48); + let __v_11: G = G::from_u64(94); + let __v_12: G = G::from_u64(105); + let __v_13: G = G::from_u64(61); + let __v_14: G = G::from_u64(206); + let __v_15: G = G::from_u64(96); + let __v_16: G = G::from_u64(81); + let __v_17: G = G::from_u64(26); + let __v_18: G = G::from_u64(254); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(250); + let __v_21: G = G::from_u64(17); + let __v_22: G = G::from_u64(188); + let __v_23: G = G::from_u64(136); + let __v_24: G = G::from_u64(68); + let __v_25: G = G::from_u64(165); + let __v_26: G = G::from_u64(194); + let __v_27: G = G::from_u64(27); + let __v_28: G = G::from_u64(191); + let __v_29: G = G::from_u64(211); + let __v_30: G = G::from_u64(33); + let __v_31: G = G::from_u64(76); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_503] = [__v_32]; if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44284,38 +44540,38 @@ fn aiur_fn_504( unconstrained: bool, ) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(248); - let __v_1: G = G::from_u64(49); - let __v_2: G = G::from_u64(57); - let __v_3: G = G::from_u64(113); - let __v_4: G = G::from_u64(187); - let __v_5: G = G::from_u64(165); - let __v_6: G = G::from_u64(238); - let __v_7: G = G::from_u64(140); - let __v_8: G = G::from_u64(129); - let __v_9: G = G::from_u64(69); - let __v_10: G = G::from_u64(84); - let __v_11: G = G::from_u64(176); - let __v_12: G = G::from_u64(192); - let __v_13: G = G::from_u64(68); - let __v_14: G = G::from_u64(122); - let __v_15: G = G::from_u64(16); - let __v_16: G = G::from_u64(193); - let __v_17: G = G::from_u64(41); - let __v_18: G = G::from_u64(180); - let __v_19: G = G::from_u64(25); - let __v_20: G = G::from_u64(69); - let __v_21: G = G::from_u64(172); - let __v_22: G = G::from_u64(95); - let __v_23: G = G::from_u64(184); - let __v_24: G = G::from_u64(23); - let __v_25: G = G::from_u64(195); - let __v_26: G = G::from_u64(252); - let __v_27: G = G::from_u64(123); - let __v_28: G = G::from_u64(152); - let __v_29: G = G::from_u64(178); - let __v_30: G = G::from_u64(58); - let __v_31: G = G::from_u64(16); + let __v_0: G = G::from_u64(171); + let __v_1: G = G::from_u64(20); + let __v_2: G = G::from_u64(112); + let __v_3: G = G::from_u64(25); + let __v_4: G = G::from_u64(100); + let __v_5: G = G::from_u64(25); + let __v_6: G = G::from_u64(247); + let __v_7: G = G::from_u64(29); + let __v_8: G = G::from_u64(6); + let __v_9: G = G::from_u64(254); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(156); + let __v_12: G = G::from_u64(203); + let __v_13: G = G::from_u64(140); + let __v_14: G = G::from_u64(29); + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(103); + let __v_17: G = G::from_u64(69); + let __v_18: G = G::from_u64(40); + let __v_19: G = G::from_u64(236); + let __v_20: G = G::from_u64(3); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(43); + let __v_23: G = G::from_u64(9); + let __v_24: G = G::from_u64(91); + let __v_25: G = G::from_u64(173); + let __v_26: G = G::from_u64(193); + let __v_27: G = G::from_u64(105); + let __v_28: G = G::from_u64(212); + let __v_29: G = G::from_u64(141); + let __v_30: G = G::from_u64(3); + let __v_31: G = G::from_u64(208); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_504] = [__v_32]; if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44333,38 +44589,38 @@ fn aiur_fn_505( unconstrained: bool, ) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(122); - let __v_1: G = G::from_u64(236); - let __v_2: G = G::from_u64(194); - let __v_3: G = G::from_u64(6); - let __v_4: G = G::from_u64(113); - let __v_5: G = G::from_u64(77); - let __v_6: G = G::from_u64(100); - let __v_7: G = G::from_u64(181); - let __v_8: G = G::from_u64(23); - let __v_9: G = G::from_u64(122); - let __v_10: G = G::from_u64(203); - let __v_11: G = G::from_u64(117); - let __v_12: G = G::from_u64(58); - let __v_13: G = G::from_u64(40); - let __v_14: G = G::from_u64(94); - let __v_15: G = G::from_u64(103); - let __v_16: G = G::from_u64(10); - let __v_17: G = G::from_u64(145); - let __v_18: G = G::from_u64(138); - let __v_19: G = G::from_u64(26); - let __v_20: G = G::from_u64(201); - let __v_21: G = G::from_u64(254); - let __v_22: G = G::from_u64(143); - let __v_23: G = G::from_u64(87); - let __v_24: G = G::from_u64(70); - let __v_25: G = G::from_u64(15); - let __v_26: G = G::from_u64(119); - let __v_27: G = G::from_u64(111); - let __v_28: G = G::from_u64(23); - let __v_29: G = G::from_u64(183); - let __v_30: G = G::from_u64(173); - let __v_31: G = G::from_u64(194); + let __v_0: G = G::from_u64(35); + let __v_1: G = G::from_u64(190); + let __v_2: G = G::from_u64(163); + let __v_3: G = G::from_u64(187); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(168); + let __v_6: G = G::from_u64(208); + let __v_7: G = G::from_u64(168); + let __v_8: G = G::from_u64(208); + let __v_9: G = G::from_u64(3); + let __v_10: G = G::from_u64(60); + let __v_11: G = G::from_u64(247); + let __v_12: G = G::from_u64(229); + let __v_13: G = G::from_u64(106); + let __v_14: G = G::from_u64(240); + let __v_15: G = G::from_u64(196); + let __v_16: G = G::from_u64(174); + let __v_17: G = G::from_u64(224); + let __v_18: G = G::from_u64(21); + let __v_19: G = G::from_u64(130); + let __v_20: G = G::from_u64(213); + let __v_21: G = G::from_u64(167); + let __v_22: G = G::from_u64(88); + let __v_23: G = G::from_u64(192); + let __v_24: G = G::from_u64(223); + let __v_25: G = G::from_u64(86); + let __v_26: G = G::from_u64(21); + let __v_27: G = G::from_u64(146); + let __v_28: G = G::from_u64(156); + let __v_29: G = G::from_u64(166); + let __v_30: G = G::from_u64(32); + let __v_31: G = G::from_u64(77); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_505] = [__v_32]; if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44382,38 +44638,38 @@ fn aiur_fn_506( unconstrained: bool, ) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(230); - let __v_1: G = G::from_u64(235); - 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_0: G = G::from_u64(190); + let __v_1: G = G::from_u64(80); + let __v_2: G = G::from_u64(182); + let __v_3: G = G::from_u64(5); + let __v_4: G = G::from_u64(61); + let __v_5: G = G::from_u64(240); + let __v_6: G = G::from_u64(176); + let __v_7: G = G::from_u64(116); + let __v_8: G = G::from_u64(56); + let __v_9: G = G::from_u64(164); + let __v_10: G = G::from_u64(172); + let __v_11: G = G::from_u64(46); + let __v_12: G = G::from_u64(239); + let __v_13: G = G::from_u64(215); + let __v_14: G = G::from_u64(10); + let __v_15: G = G::from_u64(17); + let __v_16: G = G::from_u64(112); + let __v_17: G = G::from_u64(139); + let __v_18: G = G::from_u64(12); + let __v_19: G = G::from_u64(187); + let __v_20: G = G::from_u64(15); + let __v_21: G = G::from_u64(201); + let __v_22: G = G::from_u64(5); + let __v_23: G = G::from_u64(100); + let __v_24: G = G::from_u64(186); + let __v_25: G = G::from_u64(254); + let __v_26: G = G::from_u64(230); + let __v_27: G = G::from_u64(225); + let __v_28: G = G::from_u64(101); + let __v_29: G = G::from_u64(97); + let __v_30: G = G::from_u64(93); + let __v_31: G = G::from_u64(232); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_506] = [__v_32]; if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44431,38 +44687,38 @@ fn aiur_fn_507( unconstrained: bool, ) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(108); - let __v_1: G = G::from_u64(155); - 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_0: G = G::from_u64(196); + let __v_1: G = G::from_u64(137); + let __v_2: G = G::from_u64(50); + let __v_3: G = G::from_u64(145); + let __v_4: G = G::from_u64(151); + let __v_5: G = G::from_u64(181); + let __v_6: G = G::from_u64(154); + let __v_7: G = G::from_u64(4); + let __v_8: G = G::from_u64(13); + let __v_9: G = G::from_u64(30); + let __v_10: G = G::from_u64(94); + let __v_11: G = G::from_u64(77); + let __v_12: G = G::from_u64(93); + let __v_13: G = G::from_u64(230); 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_15: G = G::from_u64(112); + let __v_16: G = G::from_u64(71); + let __v_17: G = G::from_u64(141); + let __v_18: G = G::from_u64(30); + let __v_19: G = G::from_u64(164); + let __v_20: G = G::from_u64(249); + let __v_21: G = G::from_u64(117); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(118); + let __v_24: G = G::from_u64(2); + let __v_25: G = G::from_u64(109); + let __v_26: G = G::from_u64(210); + let __v_27: G = G::from_u64(191); + let __v_28: G = G::from_u64(133); + let __v_29: G = G::from_u64(147); + let __v_30: G = G::from_u64(191); + let __v_31: G = G::from_u64(34); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_507] = [__v_32]; if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44480,38 +44736,38 @@ fn aiur_fn_508( unconstrained: bool, ) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(15); - let __v_1: G = G::from_u64(83); - let __v_2: G = G::from_u64(188); - let __v_3: G = G::from_u64(87); - let __v_4: G = G::from_u64(104); - let __v_5: G = G::from_u64(253); - let __v_6: G = G::from_u64(50); - let __v_7: G = G::from_u64(170); - let __v_8: G = G::from_u64(104); - let __v_9: G = G::from_u64(1); - let __v_10: G = G::from_u64(220); - let __v_11: G = G::from_u64(135); - let __v_12: G = G::from_u64(98); - let __v_13: G = G::from_u64(147); - let __v_14: G = G::from_u64(75); - let __v_15: G = G::from_u64(105); - let __v_16: G = G::from_u64(4); - let __v_17: G = G::from_u64(157); - let __v_18: G = G::from_u64(179); - let __v_19: G = G::from_u64(231); + let __v_0: G = G::from_u64(14); + let __v_1: G = G::from_u64(181); + let __v_2: G = G::from_u64(185); + let __v_3: G = G::from_u64(135); + let __v_4: G = G::from_u64(241); + let __v_5: G = G::from_u64(33); + let __v_6: G = G::from_u64(36); + let __v_7: G = G::from_u64(190); + let __v_8: G = G::from_u64(5); + let __v_9: G = G::from_u64(117); + let __v_10: G = G::from_u64(164); + let __v_11: G = G::from_u64(119); + let __v_12: G = G::from_u64(204); + let __v_13: G = G::from_u64(10); + let __v_14: G = G::from_u64(83); + let __v_15: G = G::from_u64(85); + let __v_16: G = G::from_u64(22); + let __v_17: G = G::from_u64(162); + let __v_18: G = G::from_u64(75); + let __v_19: G = G::from_u64(10); let __v_20: G = G::from_u64(229); - let __v_21: G = G::from_u64(116); - let __v_22: G = G::from_u64(18); - let __v_23: G = G::from_u64(198); - let __v_24: G = G::from_u64(144); - let __v_25: G = G::from_u64(77); - let __v_26: G = G::from_u64(209); - let __v_27: G = G::from_u64(168); - let __v_28: G = G::from_u64(185); - let __v_29: G = G::from_u64(207); - let __v_30: G = G::from_u64(244); - let __v_31: G = G::from_u64(248); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(221); + let __v_23: G = G::from_u64(190); + let __v_24: G = G::from_u64(226); + let __v_25: G = G::from_u64(212); + let __v_26: G = G::from_u64(114); + let __v_27: G = G::from_u64(118); + let __v_28: G = G::from_u64(90); + let __v_29: G = G::from_u64(237); + let __v_30: G = G::from_u64(41); + let __v_31: G = G::from_u64(156); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_508] = [__v_32]; if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44529,38 +44785,38 @@ fn aiur_fn_509( unconstrained: bool, ) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(14); - let __v_1: G = G::from_u64(95); - let __v_2: G = G::from_u64(112); - let __v_3: G = G::from_u64(239); - let __v_4: G = G::from_u64(218); - let __v_5: G = G::from_u64(5); - let __v_6: G = G::from_u64(152); - let __v_7: G = G::from_u64(24); - let __v_8: G = G::from_u64(40); - let __v_9: G = G::from_u64(25); - let __v_10: G = G::from_u64(161); - let __v_11: G = G::from_u64(10); - let __v_12: G = G::from_u64(35); - let __v_13: G = G::from_u64(135); - let __v_14: G = G::from_u64(150); - let __v_15: G = G::from_u64(70); - let __v_16: G = G::from_u64(45); - let __v_17: G = G::from_u64(235); - let __v_18: G = G::from_u64(192); - let __v_19: G = G::from_u64(95); - let __v_20: G = G::from_u64(64); - let __v_21: G = G::from_u64(136); - let __v_22: G = G::from_u64(129); - let __v_23: G = G::from_u64(23); - let __v_24: G = G::from_u64(209); - let __v_25: G = G::from_u64(25); - let __v_26: G = G::from_u64(105); - let __v_27: G = G::from_u64(146); - let __v_28: G = G::from_u64(185); - let __v_29: G = G::from_u64(66); - let __v_30: G = G::from_u64(63); - let __v_31: G = G::from_u64(174); + let __v_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_509] = [__v_32]; if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44578,38 +44834,38 @@ fn aiur_fn_510( unconstrained: bool, ) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(206); - let __v_1: G = G::from_u64(19); - let __v_2: G = G::from_u64(124); - let __v_3: G = G::from_u64(206); - let __v_4: G = G::from_u64(76); - let __v_5: G = G::from_u64(26); - let __v_6: G = G::from_u64(73); - let __v_7: G = G::from_u64(50); - let __v_8: G = G::from_u64(58); - let __v_9: G = G::from_u64(120); - let __v_10: G = G::from_u64(143); - let __v_11: G = G::from_u64(22); - let __v_12: G = G::from_u64(119); - let __v_13: G = G::from_u64(169); - let __v_14: G = G::from_u64(214); - let __v_15: G = G::from_u64(161); - let __v_16: G = G::from_u64(212); - let __v_17: G = G::from_u64(169); - let __v_18: G = G::from_u64(54); - let __v_19: G = G::from_u64(17); - let __v_20: G = G::from_u64(21); - let __v_21: G = G::from_u64(136); - let __v_22: G = G::from_u64(8); - let __v_23: G = G::from_u64(53); - let __v_24: G = G::from_u64(137); - let __v_25: G = G::from_u64(186); - let __v_26: G = G::from_u64(171); - let __v_27: G = G::from_u64(43); - let __v_28: G = G::from_u64(172); - let __v_29: G = G::from_u64(1); - let __v_30: G = G::from_u64(16); - let __v_31: G = G::from_u64(140); + let __v_0: G = G::from_u64(227); + let __v_1: G = G::from_u64(8); + let __v_2: G = G::from_u64(3); + let __v_3: G = G::from_u64(91); + let __v_4: G = G::from_u64(223); + let __v_5: G = G::from_u64(40); + let __v_6: G = G::from_u64(12); + let __v_7: G = G::from_u64(146); + let __v_8: G = G::from_u64(117); + let __v_9: G = G::from_u64(86); + let __v_10: G = G::from_u64(130); + let __v_11: G = G::from_u64(77); + let __v_12: G = G::from_u64(106); + let __v_13: G = G::from_u64(159); + let __v_14: G = G::from_u64(146); + let __v_15: G = G::from_u64(54); + let __v_16: G = G::from_u64(161); + let __v_17: G = G::from_u64(72); + let __v_18: G = G::from_u64(118); + let __v_19: G = G::from_u64(81); + let __v_20: G = G::from_u64(240); + let __v_21: G = G::from_u64(5); + let __v_22: G = G::from_u64(154); + let __v_23: G = G::from_u64(125); + let __v_24: G = G::from_u64(243); + let __v_25: G = G::from_u64(189); + let __v_26: G = G::from_u64(168); + let __v_27: G = G::from_u64(91); + let __v_28: G = G::from_u64(51); + let __v_29: G = G::from_u64(31); + let __v_30: G = G::from_u64(103); + let __v_31: G = G::from_u64(230); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_510] = [__v_32]; if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -44617,8 +44873,8 @@ fn aiur_fn_510( }) } -const INPUT_SIZE_511: usize = 1; -const IN_511: usize = 1; +const INPUT_SIZE_511: usize = 0; +const IN_511: usize = 0; const OUT_511: usize = 1; fn aiur_fn_511( inp: [G; IN_511], @@ -44626,83 +44882,230 @@ fn aiur_fn_511( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_511], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(122); + let __v_1: G = G::from_u64(6); + let __v_2: G = G::from_u64(73); + let __v_3: G = G::from_u64(109); + let __v_4: G = G::from_u64(7); + let __v_5: G = G::from_u64(181); + let __v_6: G = G::from_u64(151); + let __v_7: G = G::from_u64(16); + let __v_8: G = G::from_u64(52); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(95); + let __v_11: G = G::from_u64(101); + let __v_12: G = G::from_u64(120); + let __v_13: G = G::from_u64(81); + let __v_14: G = G::from_u64(164); + let __v_15: G = G::from_u64(238); + let __v_16: G = G::from_u64(161); + let __v_17: G = G::from_u64(245); + let __v_18: G = G::from_u64(148); + let __v_19: G = G::from_u64(146); + let __v_20: G = G::from_u64(165); + let __v_21: G = G::from_u64(183); + let __v_22: G = G::from_u64(222); + let __v_23: G = G::from_u64(63); + let __v_24: G = G::from_u64(81); + let __v_25: G = G::from_u64(171); + let __v_26: G = G::from_u64(188); + let __v_27: G = G::from_u64(132); + let __v_28: G = G::from_u64(249); + let __v_29: G = G::from_u64(188); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(23); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_511] = [__v_32]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_512: usize = 0; +const IN_512: usize = 0; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_512], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(20); + let __v_1: G = G::from_u64(236); + let __v_2: G = G::from_u64(206); + let __v_3: G = G::from_u64(225); + let __v_4: G = G::from_u64(222); + let __v_5: G = G::from_u64(186); + let __v_6: G = G::from_u64(5); + let __v_7: G = G::from_u64(233); + let __v_8: G = G::from_u64(68); + let __v_9: G = G::from_u64(59); + let __v_10: G = G::from_u64(209); + let __v_11: G = G::from_u64(105); + let __v_12: G = G::from_u64(208); + let __v_13: G = G::from_u64(14); + let __v_14: G = G::from_u64(214); + let __v_15: G = G::from_u64(52); + let __v_16: G = G::from_u64(23); + let __v_17: G = G::from_u64(14); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(70); + let __v_20: G = G::from_u64(179); + let __v_21: G = G::from_u64(121); + let __v_22: G = G::from_u64(33); + let __v_23: G = G::from_u64(25); + let __v_24: G = G::from_u64(158); + let __v_25: G = G::from_u64(219); + let __v_26: G = G::from_u64(186); + let __v_27: G = G::from_u64(211); + let __v_28: G = G::from_u64(246); + let __v_29: G = G::from_u64(125); + let __v_30: G = G::from_u64(181); + let __v_31: G = G::from_u64(180); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_512] = [__v_32]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_513: usize = 0; +const IN_513: usize = 0; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: [G; IN_513], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_513], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(50); + let __v_2: G = G::from_u64(192); + let __v_3: G = G::from_u64(93); + let __v_4: G = G::from_u64(126); + let __v_5: G = G::from_u64(60); + let __v_6: G = G::from_u64(93); + let __v_7: G = G::from_u64(223); + let __v_8: G = G::from_u64(78); + let __v_9: G = G::from_u64(76); + let __v_10: G = G::from_u64(133); + let __v_11: G = G::from_u64(207); + let __v_12: G = G::from_u64(143); + let __v_13: G = G::from_u64(96); + let __v_14: G = G::from_u64(216); + let __v_15: G = G::from_u64(62); + let __v_16: G = G::from_u64(15); + let __v_17: G = G::from_u64(186); + let __v_18: G = G::from_u64(85); + let __v_19: G = G::from_u64(226); + let __v_20: G = G::from_u64(103); + let __v_21: G = G::from_u64(107); + let __v_22: G = G::from_u64(248); + let __v_23: G = G::from_u64(161); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(8); + let __v_26: G = G::from_u64(219); + let __v_27: G = G::from_u64(84); + let __v_28: G = G::from_u64(177); + let __v_29: G = G::from_u64(103); + let __v_30: G = G::from_u64(201); + let __v_31: G = G::from_u64(250); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_513] = [__v_32]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_514: usize = 1; +const IN_514: usize = 1; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: [G; IN_514], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_3]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_3]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_5]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_5]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_7]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_7]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_9]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_9]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_11]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_11]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_511] = [__v_13]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_13]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_511] = [__v_13]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_13]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44719,56 +45122,56 @@ fn aiur_fn_511( }) } -const INPUT_SIZE_512: usize = 1; -const IN_512: usize = 1; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_515: usize = 1; +const IN_515: usize = 1; +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_512], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_512] = [__v_3]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_3]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_512] = [__v_5]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_5]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_512] = [__v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_7]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_512] = [__v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_7]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44779,15 +45182,15 @@ fn aiur_fn_512( }) } -const INPUT_SIZE_513: usize = 1; -const IN_513: usize = 1; -const OUT_513: usize = 3; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_516: usize = 1; +const IN_516: usize = 1; +const OUT_516: usize = 3; +fn aiur_fn_516( + inp: [G; IN_516], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -44804,11 +45207,11 @@ fn aiur_fn_513( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -44820,8 +45223,8 @@ fn aiur_fn_513( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_14, __v_15, __v_18]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_14, __v_15, __v_18]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44835,8 +45238,8 @@ fn aiur_fn_513( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_513] = [__v_18, __v_12, __v_16]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_18, __v_12, __v_16]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44845,8 +45248,8 @@ fn aiur_fn_513( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44857,8 +45260,8 @@ fn aiur_fn_513( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44871,8 +45274,8 @@ fn aiur_fn_513( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44883,34 +45286,34 @@ fn aiur_fn_513( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_514: usize = 2; -const IN_514: usize = 2; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_517: usize = 2; +const IN_517: usize = 2; +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_514], 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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -44930,27 +45333,27 @@ fn aiur_fn_514( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_514] = [__v_15]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_15]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_515: usize = 4; -const IN_515: usize = 4; -const OUT_515: usize = 2; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_518: usize = 4; +const IN_518: usize = 4; +const OUT_518: usize = 2; +fn aiur_fn_518( + inp: [G; IN_518], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -44961,24 +45364,24 @@ fn aiur_fn_515( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_515] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -44989,26 +45392,26 @@ fn aiur_fn_515( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_515] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_515] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_515] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45017,15 +45420,15 @@ fn aiur_fn_515( }) } -const INPUT_SIZE_516: usize = 6; -const IN_516: usize = 6; -const OUT_516: usize = 2; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +const OUT_519: usize = 2; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], 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]; @@ -45033,25 +45436,25 @@ fn aiur_fn_516( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); @@ -45063,13 +45466,13 @@ fn aiur_fn_516( let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_516] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45078,8 +45481,8 @@ fn aiur_fn_516( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45090,29 +45493,29 @@ fn aiur_fn_516( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_517: usize = 4; -const IN_517: usize = 4; -const OUT_517: usize = 2; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_520: usize = 4; +const IN_520: usize = 4; +const OUT_520: usize = 2; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_517], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45123,50 +45526,50 @@ fn aiur_fn_517( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_517] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_517] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_517] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45177,28 +45580,28 @@ fn aiur_fn_517( }) } -const INPUT_SIZE_518: usize = 3; -const IN_518: usize = 3; -const OUT_518: usize = 2; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_521: usize = 3; +const IN_521: usize = 3; +const OUT_521: usize = 2; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], 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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45208,17 +45611,17 @@ fn aiur_fn_518( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -45229,13 +45632,13 @@ fn aiur_fn_518( let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_518] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45245,15 +45648,15 @@ fn aiur_fn_518( }) } -const INPUT_SIZE_519: usize = 6; -const IN_519: usize = 6; -const OUT_519: usize = 2; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_522: usize = 6; +const IN_522: usize = 6; +const OUT_522: usize = 2; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], 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]; @@ -45262,16 +45665,16 @@ fn aiur_fn_519( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45281,12 +45684,12 @@ fn aiur_fn_519( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45296,30 +45699,30 @@ fn aiur_fn_519( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_519] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45334,15 +45737,15 @@ fn aiur_fn_519( }) } -const INPUT_SIZE_520: usize = 9; -const IN_520: usize = 9; -const OUT_520: usize = 2; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_523: usize = 9; +const IN_523: usize = 9; +const OUT_523: usize = 2; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], 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]; @@ -45363,8 +45766,8 @@ fn aiur_fn_520( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45380,12 +45783,12 @@ fn aiur_fn_520( let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); @@ -45394,12 +45797,12 @@ fn aiur_fn_520( let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -45422,12 +45825,12 @@ fn aiur_fn_520( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45436,12 +45839,12 @@ fn aiur_fn_520( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45465,31 +45868,31 @@ fn aiur_fn_520( let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_63, __v_64]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_63, __v_64]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_521: usize = 3; -const IN_521: usize = 3; -const OUT_521: usize = 2; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_524: usize = 3; +const IN_524: usize = 3; +const OUT_524: usize = 2; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45500,16 +45903,16 @@ fn aiur_fn_521( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -45529,7 +45932,7 @@ fn aiur_fn_521( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45538,16 +45941,16 @@ fn aiur_fn_521( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45558,8 +45961,8 @@ fn aiur_fn_521( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45570,8 +45973,8 @@ fn aiur_fn_521( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45582,8 +45985,8 @@ fn aiur_fn_521( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45594,8 +45997,8 @@ fn aiur_fn_521( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45604,15 +46007,15 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 4; -const IN_522: usize = 4; -const OUT_522: usize = 2; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_525: usize = 4; +const IN_525: usize = 4; +const OUT_525: usize = 2; +fn aiur_fn_525( + inp: [G; IN_525], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], 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]; @@ -45630,12 +46033,12 @@ fn aiur_fn_522( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -45659,18 +46062,18 @@ fn aiur_fn_522( let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45681,16 +46084,16 @@ fn aiur_fn_522( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_52, __v_56]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_52, __v_56]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); @@ -45704,28 +46107,28 @@ fn aiur_fn_522( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_522] = [__v_69, __v_70]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_69, __v_70]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_523: usize = 6; -const IN_523: usize = 6; -const OUT_523: usize = 2; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_526: usize = 6; +const IN_526: usize = 6; +const OUT_526: usize = 2; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], 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]; @@ -45735,12 +46138,12 @@ fn aiur_fn_523( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -45751,18 +46154,18 @@ fn aiur_fn_523( let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45773,13 +46176,13 @@ fn aiur_fn_523( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -45794,28 +46197,28 @@ fn aiur_fn_523( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_523] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_527: usize = 2; +const IN_527: usize = 2; +const OUT_527: usize = 1; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], 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]; @@ -45823,8 +46226,8 @@ fn aiur_fn_524( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_524] = [__v_3]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_3]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45832,14 +46235,14 @@ fn aiur_fn_524( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_4]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_4]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_524] = [__v_4]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_4]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45851,96 +46254,96 @@ fn aiur_fn_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], +const INPUT_SIZE_528: usize = 2; +const IN_528: usize = 2; +const OUT_528: usize = 1; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_525] = [__v_1]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_1]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_525] = [__v_0]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_0]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_526: usize = 0; -const IN_526: usize = 0; -const OUT_526: usize = 2; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_529: usize = 0; +const IN_529: usize = 0; +const OUT_529: usize = 2; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], ExecError> { +) -> Result<[G; OUT_529], 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_526] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_527: usize = 0; -const IN_527: usize = 0; -const OUT_527: usize = 2; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_530: usize = 0; +const IN_530: usize = 0; +const OUT_530: usize = 2; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], ExecError> { +) -> Result<[G; OUT_530], 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_527] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_530] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_528: usize = 0; -const IN_528: usize = 0; -const OUT_528: usize = 2; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_531: usize = 0; +const IN_531: usize = 0; +const OUT_531: usize = 2; +fn aiur_fn_531( + inp: [G; IN_531], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], ExecError> { +) -> Result<[G; OUT_531], 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_528] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_531] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_529: usize = 4; -const IN_529: usize = 4; -const OUT_529: usize = 2; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_532: usize = 4; +const IN_532: usize = 4; +const OUT_532: usize = 2; +fn aiur_fn_532( + inp: [G; IN_532], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], 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]; @@ -45949,46 +46352,46 @@ fn aiur_fn_529( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_529] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_532] = [__v_2, __v_4]; + if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_529] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_532] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_530: usize = 1; -const IN_530: usize = 1; -const OUT_530: usize = 2; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_533: usize = 1; +const IN_533: usize = 1; +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_530], ExecError> { +) -> Result<[G; OUT_533], 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_530] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 2; -const IN_531: usize = 2; -const OUT_531: usize = 1; -fn aiur_fn_531( - inp: [G; IN_531], +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_531], 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]; @@ -46058,51 +46461,51 @@ fn aiur_fn_531( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_531] = [__v_80]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_80]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_532: usize = 8; -const IN_532: usize = 8; -const OUT_532: usize = 1; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_535: usize = 8; +const IN_535: usize = 8; +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_532], 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]; @@ -46130,23 +46533,23 @@ fn aiur_fn_532( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_532] = [__v_26]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_26]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_533: usize = 2; -const IN_533: usize = 2; -const OUT_533: usize = 1; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_536: usize = 2; +const IN_536: usize = 2; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], 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]; @@ -46158,8 +46561,8 @@ fn aiur_fn_533( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_533] = [__v_6]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_6]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -46169,15 +46572,15 @@ fn aiur_fn_533( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_533] = [__v_8]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_533] = [__v_7]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_7]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46189,15 +46592,15 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 3; -const IN_534: usize = 3; -const OUT_534: usize = 2; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_537: usize = 3; +const IN_537: usize = 3; +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_534], 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]; @@ -46206,37 +46609,37 @@ fn aiur_fn_534( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_534] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_534] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46244,19 +46647,19 @@ fn aiur_fn_534( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46267,15 +46670,15 @@ fn aiur_fn_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], +const INPUT_SIZE_538: usize = 2; +const IN_538: usize = 2; +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_535], 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]; @@ -46292,14 +46695,14 @@ fn aiur_fn_535( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46312,21 +46715,21 @@ fn aiur_fn_535( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46339,31 +46742,31 @@ fn aiur_fn_535( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_10]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_10]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46376,37 +46779,37 @@ fn aiur_fn_535( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_10]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_10]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46421,16 +46824,16 @@ fn aiur_fn_535( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46442,15 +46845,15 @@ fn aiur_fn_535( }) } -const INPUT_SIZE_536: usize = 2; -const IN_536: usize = 2; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], 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]; @@ -46467,14 +46870,14 @@ fn aiur_fn_536( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46487,19 +46890,19 @@ fn aiur_fn_536( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_10]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_10]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46514,15 +46917,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_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_537], 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]; @@ -46532,16 +46935,16 @@ fn aiur_fn_537( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_4]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_4]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46553,15 +46956,15 @@ fn aiur_fn_537( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_4]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_4]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46576,54 +46979,54 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 2; -const IN_538: usize = 2; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_541: usize = 2; +const IN_541: usize = 2; +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_538], 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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_7]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_7]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_538] = [__v_6]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_6]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_539: usize = 2; -const IN_539: usize = 2; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_542: usize = 2; +const IN_542: usize = 2; +const OUT_542: usize = 1; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], 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]; @@ -46641,8 +47044,8 @@ fn aiur_fn_539( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_539] = [__v_12]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_12]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -46659,14 +47062,14 @@ fn aiur_fn_539( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_24]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_24]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46681,15 +47084,15 @@ fn aiur_fn_539( }) } -const INPUT_SIZE_540: usize = 16; -const IN_540: usize = 16; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_543: usize = 16; +const IN_543: usize = 16; +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_540], 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]; @@ -46707,51 +47110,51 @@ fn aiur_fn_540( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_30]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_30]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_541: usize = 2; -const IN_541: usize = 2; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_544: usize = 2; +const IN_544: usize = 2; +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_541], 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]; @@ -46768,14 +47171,14 @@ fn aiur_fn_541( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_8]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_8]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46788,19 +47191,19 @@ fn aiur_fn_541( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_8]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_10]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_10]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46815,15 +47218,15 @@ fn aiur_fn_541( }) } -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_545: usize = 3; +const IN_545: usize = 3; +const OUT_545: usize = 2; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], 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]; @@ -46831,11 +47234,11 @@ fn aiur_fn_542( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_542] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46849,26 +47252,26 @@ fn aiur_fn_542( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_542] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_543: usize = 9; -const IN_543: usize = 9; -const OUT_543: usize = 2; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_546: usize = 9; +const IN_546: usize = 9; +const OUT_546: usize = 2; +fn aiur_fn_546( + inp: [G; IN_546], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], 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]; @@ -46883,21 +47286,21 @@ fn aiur_fn_543( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46905,29 +47308,29 @@ fn aiur_fn_543( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46935,43 +47338,43 @@ fn aiur_fn_543( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46979,49 +47382,49 @@ fn aiur_fn_543( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47029,57 +47432,57 @@ fn aiur_fn_543( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47087,65 +47490,65 @@ fn aiur_fn_543( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47153,79 +47556,79 @@ fn aiur_fn_543( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47233,29 +47636,29 @@ fn aiur_fn_543( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47263,33 +47666,33 @@ fn aiur_fn_543( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47301,15 +47704,15 @@ fn aiur_fn_543( }) } -const INPUT_SIZE_544: usize = 7; -const IN_544: usize = 7; -const OUT_544: usize = 2; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_547: usize = 7; +const IN_547: usize = 7; +const OUT_547: usize = 2; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], 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]; @@ -47322,19 +47725,19 @@ fn aiur_fn_544( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_544] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47343,15 +47746,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 3; -const IN_545: usize = 3; -const OUT_545: usize = 2; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_548: usize = 3; +const IN_548: usize = 3; +const OUT_548: usize = 2; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], 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]; @@ -47372,19 +47775,19 @@ fn aiur_fn_545( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47398,25 +47801,25 @@ fn aiur_fn_545( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47431,15 +47834,15 @@ fn aiur_fn_545( }) } -const INPUT_SIZE_546: usize = 12; -const IN_546: usize = 12; -const OUT_546: usize = 1; -fn aiur_fn_546( - inp: [G; IN_546], +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_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]; @@ -47456,50 +47859,50 @@ fn aiur_fn_546( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_12]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47509,15 +47912,15 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 25; -const IN_547: usize = 25; -const OUT_547: usize = 2; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_550: usize = 25; +const IN_550: usize = 25; +const OUT_550: usize = 2; +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]; @@ -47544,42 +47947,42 @@ fn aiur_fn_547( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_548: usize = 25; -const IN_548: usize = 25; -const OUT_548: usize = 2; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_551: usize = 25; +const IN_551: usize = 25; +const OUT_551: usize = 2; +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]; @@ -47610,33 +48013,33 @@ fn aiur_fn_548( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_34, __v_35]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_34, __v_35]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47644,75 +48047,75 @@ fn aiur_fn_548( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_51, __v_52]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_51, __v_52]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_46, __v_47]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_46, __v_47]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47720,98 +48123,98 @@ fn aiur_fn_548( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_59, __v_60]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_59, __v_60]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_549: usize = 7; -const IN_549: usize = 7; -const OUT_549: usize = 2; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_552: usize = 7; +const IN_552: usize = 7; +const OUT_552: usize = 2; +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]; @@ -47823,15 +48226,15 @@ fn aiur_fn_549( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -47846,7 +48249,7 @@ fn aiur_fn_549( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -47861,34 +48264,34 @@ fn aiur_fn_549( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_40, __v_41]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_40, __v_41]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_550: usize = 25; -const IN_550: usize = 25; -const OUT_550: usize = 2; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_553: usize = 25; +const IN_553: usize = 25; +const OUT_553: usize = 2; +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]; @@ -47919,94 +48322,94 @@ fn aiur_fn_550( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_551: usize = 3; -const IN_551: usize = 3; -const OUT_551: usize = 1; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_554: usize = 3; +const IN_554: usize = 3; +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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -48015,7 +48418,7 @@ fn aiur_fn_551( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -48037,31 +48440,31 @@ fn aiur_fn_551( let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_551] = [__v_34]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_34]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_552: usize = 2; -const IN_552: usize = 2; -const OUT_552: usize = 12; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_555: usize = 2; +const IN_555: usize = 2; +const OUT_555: usize = 12; +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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -48076,25 +48479,25 @@ fn aiur_fn_552( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_553: usize = 2; -const IN_553: usize = 2; -const OUT_553: usize = 1; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_556: usize = 2; +const IN_556: usize = 2; +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]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -48109,53 +48512,53 @@ fn aiur_fn_553( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_553] = [__v_7]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_7]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_14]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_14]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 3; -const IN_554: usize = 3; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_5]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_5]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_555: usize = 5; -const IN_555: usize = 5; -const OUT_555: usize = 1; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_558: usize = 5; +const IN_558: usize = 5; +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]; @@ -48171,23 +48574,23 @@ fn aiur_fn_555( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_555] = [__v_10]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_558] = [__v_10]; + if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_555] = [__v_14]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_558] = [__v_14]; + if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48197,15 +48600,15 @@ fn aiur_fn_555( }) } -const INPUT_SIZE_556: usize = 5; -const IN_556: usize = 5; -const OUT_556: usize = 2; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_559: usize = 5; +const IN_559: usize = 5; +const OUT_559: usize = 2; +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]; @@ -48222,35 +48625,35 @@ fn aiur_fn_556( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_556] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_556] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_556] = [__v_16, __v_9]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_16, __v_9]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48262,15 +48665,15 @@ fn aiur_fn_556( }) } -const INPUT_SIZE_557: usize = 5; -const IN_557: usize = 5; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_560: usize = 5; +const IN_560: usize = 5; +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_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]; @@ -48283,37 +48686,37 @@ 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; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_557] = [__v_8]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_8]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_557] = [__v_12]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_12]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_558: usize = 3; -const IN_558: usize = 3; -const OUT_558: usize = 1; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_561: usize = 3; +const IN_561: usize = 3; +const OUT_561: usize = 1; +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]; @@ -48324,26 +48727,26 @@ fn aiur_fn_558( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_558] = [__v_11]; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_11]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_559: usize = 4; -const IN_559: usize = 4; -const OUT_559: usize = 1; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_562: usize = 4; +const IN_562: usize = 4; +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]; @@ -48351,33 +48754,33 @@ fn aiur_fn_559( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_559] = [__v_0]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_0]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_559] = [__v_0]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_0]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_559] = [__v_11]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_11]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48386,15 +48789,15 @@ fn aiur_fn_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], +const INPUT_SIZE_563: usize = 3; +const IN_563: usize = 3; +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]; @@ -48408,19 +48811,19 @@ fn aiur_fn_560( 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_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_8]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_8]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48430,28 +48833,28 @@ 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_564: usize = 3; +const IN_564: usize = 3; +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_561], ExecError> { +) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_561] = [__v_6]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_6]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -48460,32 +48863,32 @@ fn aiur_fn_561( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_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_561] = [__v_8]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_8]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_561] = [__v_5]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_5]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_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_562], 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]; @@ -48499,17 +48902,17 @@ 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; 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_562] = [__v_8]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_8]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_562] = [__v_7]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_7]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48519,15 +48922,15 @@ fn aiur_fn_562( }) } -const INPUT_SIZE_563: usize = 4; -const IN_563: usize = 4; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], +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_563], 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]; @@ -48544,12 +48947,12 @@ fn aiur_fn_563( 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_563] = [__v_11]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_11]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -48562,7 +48965,7 @@ fn aiur_fn_563( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -48575,24 +48978,24 @@ fn aiur_fn_563( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __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_563] = [__v_34]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_34]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __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_563] = [__v_35]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_35]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48604,15 +49007,15 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 3; -const IN_564: usize = 3; -const OUT_564: usize = 1; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_567: usize = 3; +const IN_567: usize = 3; +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_564], 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]; @@ -48626,8 +49029,8 @@ fn aiur_fn_564( 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_564] = [__v_8]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_8]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -48636,10 +49039,10 @@ fn aiur_fn_564( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_564] = [__v_11]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_11]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48649,15 +49052,15 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 5; -const IN_565: usize = 5; -const OUT_565: usize = 1; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_568: usize = 5; +const IN_568: usize = 5; +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_565], 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]; @@ -48675,12 +49078,12 @@ fn aiur_fn_565( 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_565] = [__v_12]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_12]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -48693,7 +49096,7 @@ fn aiur_fn_565( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -48706,17 +49109,17 @@ fn aiur_fn_565( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_565] = [__v_35]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_35]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48726,11 +49129,11 @@ fn aiur_fn_565( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __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_565] = [__v_41]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_41]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48742,15 +49145,15 @@ fn aiur_fn_565( }) } -const INPUT_SIZE_566: usize = 2; -const IN_566: usize = 2; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +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_566], 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]; @@ -48767,14 +49170,14 @@ fn aiur_fn_566( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_8]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_8]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48787,25 +49190,25 @@ fn aiur_fn_566( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_8]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_566] = [__v_9]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_9]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_566] = [__v_9]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_9]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48822,15 +49225,15 @@ fn aiur_fn_566( }) } -const INPUT_SIZE_567: usize = 1; -const IN_567: usize = 1; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_570: usize = 1; +const IN_570: usize = 1; +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_567], ExecError> { +) -> Result<[G; OUT_570], 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 }; @@ -48842,17 +49245,17 @@ fn aiur_fn_567( 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_567] = [__v_6]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_6]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_5]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_5]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48862,15 +49265,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 1; -const IN_568: usize = 1; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_571: usize = 1; +const IN_571: usize = 1; +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_568], ExecError> { +) -> Result<[G; OUT_571], 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 }; @@ -48880,25 +49283,25 @@ fn aiur_fn_568( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_568] = [__v_4]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = [__v_4]; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_5]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = [__v_5]; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_568] = [__v_5]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = [__v_5]; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48910,15 +49313,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_572: usize = 2; +const IN_572: usize = 2; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: [G; IN_572], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], 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]; @@ -48975,26 +49378,26 @@ fn aiur_fn_569( let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_569] = [__v_51]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_51]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_569] = [__v_53]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_53]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_569] = [__v_51]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_51]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49006,15 +49409,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_573: usize = 2; +const IN_573: usize = 2; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], 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]; @@ -49069,8 +49472,8 @@ fn aiur_fn_570( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_49]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_49]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -49096,15 +49499,15 @@ fn aiur_fn_570( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_570] = [__v_50]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_50]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_50]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_50]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49116,18 +49519,18 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 1; -const IN_571: usize = 1; -const OUT_571: usize = 0; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_574: usize = 1; +const IN_574: usize = 1; +const OUT_574: usize = 0; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], ExecError> { +) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -49181,31 +49584,31 @@ fn aiur_fn_571( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); @@ -49213,34 +49616,34 @@ fn aiur_fn_571( let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49249,15 +49652,15 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 12; -const IN_572: usize = 12; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_575: usize = 12; +const IN_575: usize = 12; +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_572], 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]; @@ -49273,56 +49676,56 @@ fn aiur_fn_572( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_572] = [__v_3]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_3]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_12]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_12]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_12]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_572] = [__v_4]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_4]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_12]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_572] = [__v_6]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_6]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_572] = [__v_8]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_8]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_572] = [__v_9]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = [__v_9]; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49332,15 +49735,15 @@ fn aiur_fn_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], +const INPUT_SIZE_576: usize = 1; +const IN_576: usize = 1; +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_573], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -49351,18 +49754,18 @@ fn aiur_fn_573( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_5]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_5]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -49378,67 +49781,67 @@ fn aiur_fn_573( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_573] = [__v_20]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_20]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_7]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_7]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_7]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); - let __ret: [G; OUT_573] = [__v_9]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_9]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_5]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_5]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49448,48 +49851,48 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 2; -const IN_574: usize = 2; -const OUT_574: usize = 0; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_577: usize = 2; +const IN_577: usize = 2; +const OUT_577: usize = 0; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } - let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_575: usize = 2; -const IN_575: usize = 2; -const OUT_575: usize = 0; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_578: usize = 2; +const IN_578: usize = 2; +const OUT_578: usize = 0; +fn aiur_fn_578( + inp: [G; IN_578], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], 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]; @@ -49499,28 +49902,28 @@ fn aiur_fn_575( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -49529,8 +49932,8 @@ fn aiur_fn_575( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49540,15 +49943,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 2; -const IN_576: usize = 2; -const OUT_576: usize = 0; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_579: usize = 2; +const IN_579: usize = 2; +const OUT_579: usize = 0; +fn aiur_fn_579( + inp: [G; IN_579], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_576], 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]; @@ -49558,15 +49961,15 @@ fn aiur_fn_576( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_576] = []; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_576] = []; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49576,15 +49979,15 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 3; -const IN_577: usize = 3; -const OUT_577: usize = 0; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_580: usize = 3; +const IN_580: usize = 3; +const OUT_580: usize = 0; +fn aiur_fn_580( + inp: [G; IN_580], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], 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]; @@ -49601,18 +50004,18 @@ fn aiur_fn_577( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -49627,62 +50030,62 @@ fn aiur_fn_577( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49692,64 +50095,113 @@ fn aiur_fn_577( }) } -const INPUT_SIZE_578: usize = 0; -const IN_578: usize = 0; -const OUT_578: usize = 1; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_581: usize = 0; +const IN_581: usize = 0; +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_578], ExecError> { +) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(171); - let __v_1: G = G::from_u64(104); - let __v_2: G = G::from_u64(44); - let __v_3: G = G::from_u64(23); - let __v_4: G = G::from_u64(120); - let __v_5: G = G::from_u64(161); - let __v_6: G = G::from_u64(123); - let __v_7: G = G::from_u64(190); - let __v_8: G = G::from_u64(174); - let __v_9: G = G::from_u64(64); - let __v_10: G = G::from_u64(50); - let __v_11: G = G::from_u64(151); - let __v_12: G = G::from_u64(77); - let __v_13: G = G::from_u64(243); - let __v_14: G = G::from_u64(100); - let __v_15: G = G::from_u64(71); - let __v_16: G = G::from_u64(206); - let __v_17: G = G::from_u64(139); - let __v_18: G = G::from_u64(252); - let __v_19: G = G::from_u64(171); - let __v_20: G = G::from_u64(103); - let __v_21: G = G::from_u64(100); - let __v_22: G = G::from_u64(163); - let __v_23: G = G::from_u64(109); - let __v_24: G = G::from_u64(55); - let __v_25: G = G::from_u64(133); - let __v_26: G = G::from_u64(102); - let __v_27: G = G::from_u64(227); - let __v_28: G = G::from_u64(173); - let __v_29: G = G::from_u64(99); - let __v_30: G = G::from_u64(202); - let __v_31: G = G::from_u64(184); + let __v_0: G = G::from_u64(231); + let __v_1: G = G::from_u64(117); + let __v_2: G = G::from_u64(170); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(117); + let __v_5: G = G::from_u64(154); + let __v_6: G = G::from_u64(157); + let __v_7: G = G::from_u64(74); + let __v_8: G = G::from_u64(205); + let __v_9: G = G::from_u64(188); + let __v_10: G = G::from_u64(43); + let __v_11: G = G::from_u64(133); + let __v_12: G = G::from_u64(25); + let __v_13: G = G::from_u64(255); + let __v_14: G = G::from_u64(115); + let __v_15: G = G::from_u64(245); + let __v_16: G = G::from_u64(117); + let __v_17: G = G::from_u64(82); + let __v_18: G = G::from_u64(187); + let __v_19: G = G::from_u64(12); + let __v_20: G = G::from_u64(186); + let __v_21: G = G::from_u64(77); + let __v_22: G = G::from_u64(175); + let __v_23: G = G::from_u64(22); + let __v_24: G = G::from_u64(89); + let __v_25: G = G::from_u64(187); + let __v_26: G = G::from_u64(160); + let __v_27: G = G::from_u64(15); + let __v_28: G = G::from_u64(106); + let __v_29: G = G::from_u64(147); + let __v_30: G = G::from_u64(27); + let __v_31: G = G::from_u64(75); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_578] = [__v_32]; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_581] = [__v_32]; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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], +const INPUT_SIZE_582: usize = 0; +const IN_582: usize = 0; +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_579], ExecError> { +) -> Result<[G; OUT_582], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(178); + let __v_1: G = G::from_u64(14); + let __v_2: G = G::from_u64(161); + let __v_3: G = G::from_u64(123); + let __v_4: G = G::from_u64(163); + let __v_5: G = G::from_u64(217); + let __v_6: G = G::from_u64(114); + let __v_7: G = G::from_u64(63); + let __v_8: G = G::from_u64(11); + let __v_9: G = G::from_u64(208); + let __v_10: G = G::from_u64(100); + let __v_11: G = G::from_u64(87); + let __v_12: G = G::from_u64(217); + let __v_13: G = G::from_u64(207); + let __v_14: G = G::from_u64(72); + let __v_15: G = G::from_u64(206); + let __v_16: G = G::from_u64(38); + let __v_17: G = G::from_u64(202); + let __v_18: G = G::from_u64(54); + let __v_19: G = G::from_u64(97); + let __v_20: G = G::from_u64(155); + let __v_21: G = G::from_u64(148); + let __v_22: G = G::from_u64(105); + let __v_23: G = G::from_u64(128); + let __v_24: G = G::from_u64(98); + let __v_25: G = G::from_u64(125); + let __v_26: G = G::from_u64(233); + let __v_27: G = G::from_u64(35); + let __v_28: G = G::from_u64(135); + let __v_29: G = G::from_u64(62); + let __v_30: G = G::from_u64(149); + let __v_31: G = G::from_u64(149); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_583: usize = 3; +const IN_583: usize = 3; +const OUT_583: usize = 1; +fn aiur_fn_583( + inp: [G; IN_583], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -49758,8 +50210,8 @@ fn aiur_fn_579( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_579] = [__v_4]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_4]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49772,16 +50224,16 @@ fn aiur_fn_579( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_579] = [__v_10]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_10]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_579] = [__v_8]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_8]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49790,98 +50242,67 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 0; -const IN_580: usize = 0; -const OUT_580: usize = 0; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_584: usize = 0; +const IN_584: usize = 0; +const OUT_584: usize = 0; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(3); - let __v_1: G = G::from_u64(107); - 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(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 __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; - let __v_34: G = __loaded[0]; - let __v_35: G = __loaded[1]; - let __v_36: G = __loaded[2]; - let __v_37: G = __loaded[3]; - let __v_38: G = __loaded[4]; - let __v_39: G = __loaded[5]; - let __v_40: G = __loaded[6]; - let __v_41: G = __loaded[7]; - let __v_42: G = __loaded[8]; - let __v_43: G = __loaded[9]; - let __v_44: G = __loaded[10]; - let __v_45: G = __loaded[11]; - match __v_34.as_canonical_u64() { + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_0: G = __r_arr[0]; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + match __v_2.as_canonical_u64() { 5u64 => { - let __v_46: G = G::from_u64(1); - if (__v_35 != __v_46) { - return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); + let __v_14: G = G::from_u64(1); + if (__v_3 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) }); } - let __v_47: G = G::from_u64(2); - if (__v_37 != __v_47) { - return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); + let __v_15: G = G::from_u64(2); + if (__v_5 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) }); } - let __v_48: G = G::from_u64(1); - if (__v_39 != __v_48) { - return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); + let __v_16: G = G::from_u64(1); + if (__v_7 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_581: usize = 4; -const IN_581: usize = 4; -const OUT_581: usize = 0; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_585: usize = 4; +const IN_585: usize = 4; +const OUT_585: usize = 0; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], 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]; @@ -49889,7 +50310,7 @@ fn aiur_fn_581( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -49902,7 +50323,7 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -49915,8 +50336,8 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -49929,7 +50350,7 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -49952,34 +50373,34 @@ fn aiur_fn_581( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_585] = []; + if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_582: usize = 2; -const IN_582: usize = 2; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_586: usize = 2; +const IN_586: usize = 2; +const OUT_586: usize = 1; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_582] = [__v_0]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = [__v_0]; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49992,10 +50413,10 @@ fn aiur_fn_582( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_582] = [__v_8]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = [__v_8]; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50007,29 +50428,29 @@ fn aiur_fn_582( }) } -const INPUT_SIZE_583: usize = 3; -const IN_583: usize = 3; -const OUT_583: usize = 0; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_587: usize = 3; +const IN_587: usize = 3; +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_583], 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]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } - let __ret: [G; OUT_583] = []; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50049,12 +50470,12 @@ fn aiur_fn_583( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } - let __ret: [G; OUT_583] = []; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50071,15 +50492,15 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 4; -const IN_584: usize = 4; -const OUT_584: usize = 0; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_588: usize = 4; +const IN_588: usize = 4; +const OUT_588: usize = 0; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], 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]; @@ -50088,8 +50509,8 @@ fn aiur_fn_584( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50108,7 +50529,7 @@ fn aiur_fn_584( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -50116,8 +50537,8 @@ fn aiur_fn_584( if (__v_9 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50134,20 +50555,20 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 3; -const IN_585: usize = 3; -const OUT_585: usize = 0; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_589: usize = 3; +const IN_589: usize = 3; +const OUT_589: usize = 0; +fn aiur_fn_589( + inp: [G; IN_589], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], ExecError> { +) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50173,8 +50594,8 @@ fn aiur_fn_585( if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } - let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = []; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50184,15 +50605,15 @@ fn aiur_fn_585( }) } -const INPUT_SIZE_586: usize = 7; -const IN_586: usize = 7; -const OUT_586: usize = 0; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_590: usize = 7; +const IN_590: usize = 7; +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_586], 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]; @@ -50202,9 +50623,9 @@ fn aiur_fn_586( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -50214,32 +50635,32 @@ fn aiur_fn_586( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50249,15 +50670,15 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 4; -const IN_587: usize = 4; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], 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]; @@ -50265,8 +50686,8 @@ fn aiur_fn_587( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50284,7 +50705,7 @@ fn aiur_fn_587( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -50294,9 +50715,9 @@ fn aiur_fn_587( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50313,15 +50734,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 3; -const IN_588: usize = 3; -const OUT_588: usize = 0; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_592: usize = 3; +const IN_592: usize = 3; +const OUT_592: usize = 0; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], 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]; @@ -50329,27 +50750,27 @@ fn aiur_fn_588( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -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_593: usize = 3; +const IN_593: usize = 3; +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_589], ExecError> { +) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -50360,8 +50781,8 @@ fn aiur_fn_589( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_589] = [__v_5]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_5]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50381,10 +50802,10 @@ fn aiur_fn_589( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_12]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_12]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50396,15 +50817,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 3; -const IN_590: usize = 3; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_594: usize = 3; +const IN_594: usize = 3; +const OUT_594: usize = 0; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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]; @@ -50416,9 +50837,9 @@ fn aiur_fn_590( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -50426,29 +50847,29 @@ fn aiur_fn_590( } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_594] = []; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = []; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_591: usize = 4; -const IN_591: usize = 4; -const OUT_591: usize = 0; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_595: usize = 4; +const IN_595: usize = 4; +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_591], 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]; @@ -50456,9 +50877,9 @@ fn aiur_fn_591( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_595] = []; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50473,9 +50894,9 @@ fn aiur_fn_591( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_595] = []; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50487,15 +50908,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 3; -const IN_592: usize = 3; -const OUT_592: usize = 0; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_596: usize = 3; +const IN_596: usize = 3; +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_592], 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]; @@ -50506,52 +50927,52 @@ fn aiur_fn_592( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = []; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_596] = []; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_593: usize = 2; -const IN_593: usize = 2; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_597: usize = 2; +const IN_597: usize = 2; +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_593], ExecError> { +) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_2]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_2]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_594: usize = 2; -const IN_594: usize = 2; -const OUT_594: usize = 1; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_598: usize = 2; +const IN_598: usize = 2; +const OUT_598: usize = 1; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], 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]; @@ -50562,8 +50983,8 @@ fn aiur_fn_594( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_594] = [__v_5]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_5]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -50572,15 +50993,15 @@ fn aiur_fn_594( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_594] = [__v_6]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_6]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_594] = [__v_6]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_6]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50592,19 +51013,19 @@ fn aiur_fn_594( }) } -const INPUT_SIZE_595: usize = 2; -const IN_595: usize = 2; -const OUT_595: usize = 1; -fn aiur_fn_595( - inp: [G; IN_595], +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_595], ExecError> { +) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -50621,31 +51042,31 @@ fn aiur_fn_595( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_595] = [__v_15]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = [__v_15]; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_595] = [__v_15]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = [__v_15]; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_596: usize = 2; -const IN_596: usize = 2; -const OUT_596: usize = 1; -fn aiur_fn_596( - inp: [G; IN_596], +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_596], 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]; @@ -50657,105 +51078,105 @@ fn aiur_fn_596( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_8]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_8]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_8]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_8]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50764,15 +51185,15 @@ fn aiur_fn_596( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50782,15 +51203,15 @@ fn aiur_fn_596( }) } -const INPUT_SIZE_597: usize = 2; -const IN_597: usize = 2; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_601: usize = 2; +const IN_601: usize = 2; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], 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]; @@ -50801,25 +51222,25 @@ fn aiur_fn_597( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_597] = [__v_5]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_5]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_597] = [__v_6]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_6]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_6]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_6]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50831,23 +51252,23 @@ fn aiur_fn_597( }) } -const INPUT_SIZE_598: usize = 3; -const IN_598: usize = 3; -const OUT_598: usize = 2; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_602: usize = 3; +const IN_602: usize = 3; +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_598], ExecError> { +) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_598] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50862,16 +51283,16 @@ fn aiur_fn_598( let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_598] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_598] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50880,15 +51301,15 @@ fn aiur_fn_598( }) } -const INPUT_SIZE_599: usize = 4; -const IN_599: usize = 4; -const OUT_599: usize = 0; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_603: usize = 4; +const IN_603: usize = 4; +const OUT_603: usize = 0; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], 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]; @@ -50897,8 +51318,8 @@ fn aiur_fn_599( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_599] = []; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50923,9 +51344,9 @@ fn aiur_fn_599( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_599] = []; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50942,22 +51363,22 @@ fn aiur_fn_599( }) } -const INPUT_SIZE_600: usize = 5; -const IN_600: usize = 5; -const OUT_600: usize = 0; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_604: usize = 5; +const IN_604: usize = 5; +const OUT_604: usize = 0; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -50975,25 +51396,25 @@ fn aiur_fn_600( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_600] = []; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_604] = []; + if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51003,30 +51424,30 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 4; -const IN_601: usize = 4; -const OUT_601: usize = 0; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_605: usize = 4; +const IN_605: usize = 4; +const OUT_605: usize = 0; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51037,19 +51458,19 @@ fn aiur_fn_601( 5u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -51059,28 +51480,28 @@ fn aiur_fn_601( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -51097,24 +51518,24 @@ fn aiur_fn_601( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51135,15 +51556,15 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 7; -const IN_602: usize = 7; -const OUT_602: usize = 0; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_606: usize = 7; +const IN_606: usize = 7; +const OUT_606: usize = 0; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], 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]; @@ -51155,12 +51576,12 @@ fn aiur_fn_602( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_602] = []; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -51180,22 +51601,22 @@ fn aiur_fn_602( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_602] = []; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51207,15 +51628,15 @@ fn aiur_fn_602( }) } -const INPUT_SIZE_603: usize = 4; -const IN_603: usize = 4; -const OUT_603: usize = 0; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_607: usize = 4; +const IN_607: usize = 4; +const OUT_607: usize = 0; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51228,32 +51649,32 @@ fn aiur_fn_603( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_604: usize = 4; -const IN_604: usize = 4; -const OUT_604: usize = 0; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_608: usize = 4; +const IN_608: usize = 4; +const OUT_608: usize = 0; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], 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]; @@ -51264,26 +51685,26 @@ fn aiur_fn_604( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_604] = []; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_605: usize = 8; -const IN_605: usize = 8; -const OUT_605: usize = 0; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_609: usize = 8; +const IN_609: usize = 8; +const OUT_609: usize = 0; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], 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]; @@ -51297,25 +51718,25 @@ fn aiur_fn_605( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_606: usize = 10; -const IN_606: usize = 10; -const OUT_606: usize = 0; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_610: usize = 10; +const IN_610: usize = 10; +const OUT_610: usize = 0; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], 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]; @@ -51330,12 +51751,12 @@ fn aiur_fn_606( let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = []; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -51352,15 +51773,15 @@ fn aiur_fn_606( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -51385,9 +51806,9 @@ fn aiur_fn_606( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_610] = []; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51399,15 +51820,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 12; -const IN_607: usize = 12; -const OUT_607: usize = 0; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_611: usize = 12; +const IN_611: usize = 12; +const OUT_611: usize = 0; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], 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]; @@ -51423,29 +51844,29 @@ fn aiur_fn_607( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_611] = []; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = []; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 13; -const IN_608: usize = 13; -const OUT_608: usize = 0; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_612: usize = 13; +const IN_612: usize = 13; +const OUT_612: usize = 0; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], 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]; @@ -51466,12 +51887,12 @@ fn aiur_fn_608( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -51525,14 +51946,14 @@ fn aiur_fn_608( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51542,23 +51963,23 @@ fn aiur_fn_608( } }, _ => { - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_609: usize = 7; -const IN_609: usize = 7; -const OUT_609: usize = 0; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_613: usize = 7; +const IN_613: usize = 7; +const OUT_613: usize = 0; +fn aiur_fn_613( + inp: [G; IN_613], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], 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]; @@ -51617,8 +52038,8 @@ fn aiur_fn_609( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -51630,13 +52051,13 @@ fn aiur_fn_609( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -51653,23 +52074,23 @@ fn aiur_fn_609( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -51677,17 +52098,17 @@ fn aiur_fn_609( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51697,9 +52118,9 @@ fn aiur_fn_609( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51711,15 +52132,15 @@ fn aiur_fn_609( }) } -const INPUT_SIZE_610: usize = 16; -const IN_610: usize = 16; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_614: usize = 16; +const IN_614: usize = 16; +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_610], 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]; @@ -51737,37 +52158,37 @@ fn aiur_fn_610( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51776,26 +52197,26 @@ fn aiur_fn_610( match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_20]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_20]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51804,8 +52225,8 @@ fn aiur_fn_610( }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51816,15 +52237,15 @@ fn aiur_fn_610( }) } -const INPUT_SIZE_611: usize = 4; -const IN_611: usize = 4; -const OUT_611: usize = 1; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_615: usize = 4; +const IN_615: usize = 4; +const OUT_615: usize = 1; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], 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]; @@ -51836,10 +52257,10 @@ fn aiur_fn_611( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_8]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_8]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51854,16 +52275,16 @@ fn aiur_fn_611( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_12]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_12]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_611] = [__v_8]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_8]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51872,15 +52293,15 @@ fn aiur_fn_611( }) } -const INPUT_SIZE_612: usize = 5; -const IN_612: usize = 5; -const OUT_612: usize = 1; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_616: usize = 5; +const IN_616: usize = 5; +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_612], 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]; @@ -51890,13 +52311,13 @@ fn aiur_fn_612( let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_8]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_8]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51907,13 +52328,13 @@ fn aiur_fn_612( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -51935,16 +52356,16 @@ fn aiur_fn_612( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_25]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_25]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_612] = [__v_10]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_10]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51953,15 +52374,15 @@ fn aiur_fn_612( }) } -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_617: usize = 2; +const IN_617: usize = 2; +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_613], 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]; @@ -51972,25 +52393,25 @@ fn aiur_fn_613( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_613] = [__v_5]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_5]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_613] = [__v_6]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_6]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_6]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_6]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52002,15 +52423,15 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 2; -const IN_614: usize = 2; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +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_614], 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]; @@ -52021,8 +52442,8 @@ fn aiur_fn_614( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_5]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_5]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52037,24 +52458,24 @@ fn aiur_fn_614( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_10]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_10]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_10]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_9]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_9]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52066,15 +52487,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 13; -const IN_615: usize = 13; -const OUT_615: usize = 1; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_619: usize = 13; +const IN_619: usize = 13; +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_615], 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]; @@ -52091,13 +52512,13 @@ fn aiur_fn_615( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_14]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_14]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52105,25 +52526,25 @@ fn aiur_fn_615( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_23]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_23]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -52141,22 +52562,22 @@ fn aiur_fn_615( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_615] = [__v_37]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_37]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_37]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_37]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_23]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_23]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52167,23 +52588,23 @@ fn aiur_fn_615( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_13]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_13]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_616: usize = 2; -const IN_616: usize = 2; -const OUT_616: usize = 1; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_620: usize = 2; +const IN_620: usize = 2; +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_616], 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]; @@ -52192,12 +52613,12 @@ fn aiur_fn_616( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_616] = [__v_3]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_3]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52251,16 +52672,16 @@ fn aiur_fn_616( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_52]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_52]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_51]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_51]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52271,18 +52692,18 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 1; -const IN_617: usize = 1; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_621: usize = 1; +const IN_621: usize = 1; +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_617], ExecError> { +) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -52336,14 +52757,14 @@ fn aiur_fn_617( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_617] = [__v_49]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_49]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_49]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_49]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52352,15 +52773,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_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_618], 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]; @@ -52417,14 +52838,14 @@ fn aiur_fn_618( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52434,17 +52855,17 @@ fn aiur_fn_618( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_51]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_51]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52456,15 +52877,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 5; -const IN_619: usize = 5; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_623: usize = 5; +const IN_623: usize = 5; +const OUT_623: usize = 1; +fn aiur_fn_623( + inp: [G; IN_623], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], 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]; @@ -52474,7 +52895,7 @@ fn aiur_fn_619( let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -52483,7 +52904,7 @@ fn aiur_fn_619( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52493,8 +52914,8 @@ fn aiur_fn_619( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_619] = [__v_16]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_16]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52509,15 +52930,15 @@ fn aiur_fn_619( }) } -const INPUT_SIZE_620: usize = 12; -const IN_620: usize = 12; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_624: usize = 12; +const IN_624: usize = 12; +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_620], 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]; @@ -52536,7 +52957,7 @@ fn aiur_fn_620( let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -52545,7 +52966,7 @@ fn aiur_fn_620( let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52555,16 +52976,16 @@ fn aiur_fn_620( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_620] = [__v_24]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_24]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_620] = [__v_28]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_28]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52573,8 +52994,8 @@ fn aiur_fn_620( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_620] = [__v_22]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_22]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52583,23 +53004,23 @@ fn aiur_fn_620( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_620] = [__v_14]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_14]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_621: usize = 6; -const IN_621: usize = 6; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +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_621], 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]; @@ -52610,7 +53031,7 @@ fn aiur_fn_621( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -52619,17 +53040,17 @@ fn aiur_fn_621( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_621] = [__v_19]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_19]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52639,15 +53060,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 2; -const IN_622: usize = 2; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_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_622], 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]; @@ -52660,13 +53081,13 @@ fn aiur_fn_622( 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_622] = [__v_7]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_7]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -52674,13 +53095,13 @@ fn aiur_fn_622( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_622] = [__v_12]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_12]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52690,15 +53111,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 3; -const IN_623: usize = 3; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_627: usize = 3; +const IN_627: usize = 3; +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_623], 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]; @@ -52709,8 +53130,8 @@ fn aiur_fn_623( 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_623] = [__v_6]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_6]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52721,30 +53142,30 @@ fn aiur_fn_623( 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_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __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_623] = [__v_12]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_624: usize = 2; -const IN_624: usize = 2; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_628: usize = 2; +const IN_628: usize = 2; +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_624], ExecError> { +) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -52798,14 +53219,14 @@ fn aiur_fn_624( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_624] = [__v_51]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_51]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -52823,7 +53244,7 @@ fn aiur_fn_624( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); @@ -52834,16 +53255,16 @@ fn aiur_fn_624( let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_73]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_73]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_65]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_65]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52854,15 +53275,15 @@ fn aiur_fn_624( }) } -const INPUT_SIZE_625: usize = 5; -const IN_625: usize = 5; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_629: usize = 5; +const IN_629: usize = 5; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], 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]; @@ -52922,16 +53343,16 @@ fn aiur_fn_625( let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_54]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_54]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -52958,7 +53379,7 @@ fn aiur_fn_625( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -52967,20 +53388,20 @@ fn aiur_fn_625( let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_77]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_77]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_625] = [__v_54]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_54]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52992,15 +53413,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 3; -const IN_626: usize = 3; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_630: usize = 3; +const IN_630: usize = 3; +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_626], 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]; @@ -53015,8 +53436,8 @@ fn aiur_fn_626( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_626] = [__v_9]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_9]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -53026,38 +53447,38 @@ fn aiur_fn_626( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_626] = [__v_11]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_11]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_626] = [__v_11]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_11]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_626] = [__v_10]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_10]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_626] = [__v_9]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_9]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53069,15 +53490,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_631: usize = 2; +const IN_631: usize = 2; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: [G; IN_631], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], 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]; @@ -53085,8 +53506,8 @@ fn aiur_fn_627( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_627] = [__v_3]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_3]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53108,22 +53529,22 @@ fn aiur_fn_627( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53136,16 +53557,16 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53162,24 +53583,24 @@ fn aiur_fn_627( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53192,28 +53613,28 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53226,28 +53647,28 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53260,28 +53681,28 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53294,40 +53715,40 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53340,16 +53761,16 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53369,32 +53790,32 @@ fn aiur_fn_627( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53408,15 +53829,15 @@ fn aiur_fn_627( }) } -const INPUT_SIZE_628: usize = 2; -const IN_628: usize = 2; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_632: usize = 2; +const IN_632: usize = 2; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], 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]; @@ -53433,14 +53854,14 @@ fn aiur_fn_628( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53453,25 +53874,25 @@ fn aiur_fn_628( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_9]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_9]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_628] = [__v_9]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_9]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53488,15 +53909,15 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 2; -const IN_629: usize = 2; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_633: usize = 2; +const IN_633: usize = 2; +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_629], 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]; @@ -53513,14 +53934,14 @@ fn aiur_fn_629( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53533,25 +53954,25 @@ fn aiur_fn_629( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_9]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_9]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_629] = [__v_9]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_9]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53568,15 +53989,15 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 13; -const IN_630: usize = 13; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_634: usize = 13; +const IN_634: usize = 13; +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_630], 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]; @@ -53593,37 +54014,37 @@ fn aiur_fn_630( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_13]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_13]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_630] = [__v_15]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_15]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_631: usize = 2; -const IN_631: usize = 2; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_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_631], ExecError> { +) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53677,15 +54098,15 @@ fn aiur_fn_631( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_51]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_51]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_631] = [__v_1]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_1]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53694,15 +54115,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 5; -const IN_632: usize = 5; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_636: usize = 5; +const IN_636: usize = 5; +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_632], 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]; @@ -53759,16 +54180,16 @@ fn aiur_fn_632( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -53785,9 +54206,9 @@ fn aiur_fn_632( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; @@ -53804,20 +54225,20 @@ fn aiur_fn_632( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_632] = [__v_75]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_75]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53825,10 +54246,10 @@ fn aiur_fn_632( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_54]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_54]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53840,20 +54261,20 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 3; -const IN_633: usize = 3; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_637: usize = 3; +const IN_637: usize = 3; +const OUT_637: usize = 1; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], 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 __v_2: G = inp[2]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -53907,7 +54328,7 @@ fn aiur_fn_633( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -53919,7 +54340,7 @@ fn aiur_fn_633( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -53973,12 +54394,12 @@ fn aiur_fn_633( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; @@ -53996,7 +54417,7 @@ fn aiur_fn_633( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); @@ -54022,40 +54443,40 @@ fn aiur_fn_633( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_633] = [__v_100]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_100]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_102]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_102]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_634: usize = 4; -const IN_634: usize = 4; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_638: usize = 4; +const IN_638: usize = 4; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], ExecError> { +) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -54109,15 +54530,15 @@ fn aiur_fn_634( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_53]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_53]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_634] = [__v_3]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_3]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54126,15 +54547,15 @@ fn aiur_fn_634( }) } -const INPUT_SIZE_635: usize = 7; -const IN_635: usize = 7; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_639: usize = 7; +const IN_639: usize = 7; +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_635], 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]; @@ -54193,16 +54614,16 @@ fn aiur_fn_635( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_635] = [__v_5]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_5]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; @@ -54219,9 +54640,9 @@ fn aiur_fn_635( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; @@ -54280,39 +54701,39 @@ fn aiur_fn_635( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_75]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_75]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { 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_74: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_78]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_78]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_80]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_80]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54322,10 +54743,10 @@ fn aiur_fn_635( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_56]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_56]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54337,15 +54758,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 3; -const IN_636: usize = 3; -const OUT_636: usize = 2; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_640: usize = 3; +const IN_640: usize = 3; +const OUT_640: usize = 2; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], 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]; @@ -54361,8 +54782,8 @@ fn aiur_fn_636( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_636] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -54371,18 +54792,18 @@ fn aiur_fn_636( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_636] = [__v_10, __v_2]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_10, __v_2]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_636] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54394,15 +54815,15 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 5; -const IN_637: usize = 5; -const OUT_637: usize = 2; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_641: usize = 5; +const IN_641: usize = 5; +const OUT_641: usize = 2; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], 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]; @@ -54420,8 +54841,8 @@ fn aiur_fn_637( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_637] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -54442,7 +54863,7 @@ fn aiur_fn_637( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -54458,18 +54879,18 @@ fn aiur_fn_637( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_637] = [__v_17, __v_4]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_17, __v_4]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_637] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54481,15 +54902,15 @@ fn aiur_fn_637( }) } -const INPUT_SIZE_638: usize = 2; -const IN_638: usize = 2; -const OUT_638: usize = 4; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_642: usize = 2; +const IN_642: usize = 2; +const OUT_642: usize = 4; +fn aiur_fn_642( + inp: [G; IN_642], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], 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]; @@ -54542,27 +54963,27 @@ fn aiur_fn_638( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_638] = [__v_40, __v_41, __v_44, __v_47]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_40, __v_41, __v_44, __v_47]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_638] = [__v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __ret: [G; OUT_638] = [__v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54574,15 +54995,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 4; -const IN_639: usize = 4; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_643: usize = 4; +const IN_643: usize = 4; +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_639], 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]; @@ -54596,20 +55017,20 @@ fn aiur_fn_639( 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_639] = [__v_9]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_9]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_6]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_6]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54619,8 +55040,8 @@ fn aiur_fn_639( 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_639] = [__v_11]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_11]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54629,15 +55050,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 6; -const IN_640: usize = 6; -const OUT_640: usize = 1; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_644: usize = 6; +const IN_644: usize = 6; +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_640], 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]; @@ -54647,8 +55068,8 @@ fn aiur_fn_640( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_640] = [__v_0]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_0]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54659,19 +55080,19 @@ fn aiur_fn_640( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0]; - let __ret: [G; OUT_640] = [__v_17]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_17]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54683,15 +55104,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_645: usize = 2; +const IN_645: usize = 2; +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_641], 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]; @@ -54700,8 +55121,8 @@ fn aiur_fn_641( 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_641] = [__v_4]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_4]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54715,18 +55136,18 @@ fn aiur_fn_641( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __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_641] = [__v_10]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_10]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -54738,19 +55159,19 @@ fn aiur_fn_641( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_641] = [__v_18]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_18]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_641] = [__v_16]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_16]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54761,15 +55182,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 4; -const IN_642: usize = 4; -const OUT_642: usize = 1; -fn aiur_fn_642( - inp: [G; IN_642], +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_642], 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]; @@ -54778,8 +55199,8 @@ fn aiur_fn_642( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_0]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_0]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54795,25 +55216,25 @@ fn aiur_fn_642( 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_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_642] = [__v_17]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_17]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -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_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_643], 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]; @@ -54824,21 +55245,21 @@ fn aiur_fn_643( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_643] = [__v_0]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_11]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_11]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54848,15 +55269,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 5; -const IN_644: usize = 5; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +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_644], 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]; @@ -54866,32 +55287,32 @@ fn aiur_fn_644( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_6]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_6]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_5]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_5]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_649: usize = 3; +const IN_649: usize = 3; +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_645], 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]; @@ -54899,8 +55320,8 @@ fn aiur_fn_645( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_645] = [__v_0]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_0]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54915,25 +55336,25 @@ fn aiur_fn_645( 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_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0]; - let __ret: [G; OUT_645] = [__v_15]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_15]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_646: usize = 2; -const IN_646: usize = 2; -const OUT_646: usize = 1; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_650: usize = 2; +const IN_650: usize = 2; +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_646], 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]; @@ -54943,18 +55364,18 @@ fn aiur_fn_646( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_646] = [__v_0]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_0]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __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_646] = [__v_8]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_8]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54964,15 +55385,15 @@ fn aiur_fn_646( }) } -const INPUT_SIZE_647: usize = 2; -const IN_647: usize = 2; -const OUT_647: usize = 2; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 2; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], 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]; @@ -54981,8 +55402,8 @@ fn aiur_fn_647( 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_647] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54995,20 +55416,20 @@ fn aiur_fn_647( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -55019,21 +55440,21 @@ fn aiur_fn_647( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_19, __v_17]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_19, __v_17]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55044,15 +55465,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 3; -const IN_648: usize = 3; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; +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_648], 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]; @@ -55066,21 +55487,21 @@ fn aiur_fn_648( 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_648] = [__v_8]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_8]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_648] = [__v_11]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_11]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55090,15 +55511,15 @@ fn aiur_fn_648( }) } -const INPUT_SIZE_649: usize = 6; -const IN_649: usize = 6; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_653: usize = 6; +const IN_653: usize = 6; +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_649], 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]; @@ -55108,33 +55529,33 @@ fn aiur_fn_649( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_6]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_6]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_7]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_7]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_650: usize = 3; -const IN_650: usize = 3; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_654: usize = 3; +const IN_654: usize = 3; +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_650], 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]; @@ -55142,8 +55563,8 @@ fn aiur_fn_650( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_650] = [__v_0]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_0]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55156,25 +55577,25 @@ fn aiur_fn_650( 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_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_650] = [__v_13]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_13]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_651: usize = 9; -const IN_651: usize = 9; -const OUT_651: usize = 1; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_655: usize = 9; +const IN_655: usize = 9; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], 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]; @@ -55185,12 +55606,12 @@ fn aiur_fn_651( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); @@ -55198,12 +55619,12 @@ fn aiur_fn_651( let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -55211,7 +55632,7 @@ fn aiur_fn_651( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -55219,45 +55640,45 @@ fn aiur_fn_651( let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_651] = [__v_25]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_25]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_652: usize = 3; -const IN_652: usize = 3; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_656: usize = 3; +const IN_656: usize = 3; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_4]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_656] = [__v_4]; + if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_653: usize = 4; -const IN_653: usize = 4; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_657: usize = 4; +const IN_657: usize = 4; +const OUT_657: usize = 1; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], 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]; @@ -55266,8 +55687,8 @@ fn aiur_fn_653( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_653] = [__v_0]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = [__v_0]; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55280,25 +55701,25 @@ fn aiur_fn_653( 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_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_14]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = [__v_14]; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_654: usize = 2; -const IN_654: usize = 2; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 1; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], 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]; @@ -55308,18 +55729,18 @@ fn aiur_fn_654( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_654] = [__v_0]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_658] = [__v_0]; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __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_654] = [__v_8]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_658] = [__v_8]; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55329,15 +55750,15 @@ fn aiur_fn_654( }) } -const INPUT_SIZE_655: usize = 9; -const IN_655: usize = 9; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_659: usize = 9; +const IN_659: usize = 9; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], 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]; @@ -55349,12 +55770,12 @@ fn aiur_fn_655( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55371,32 +55792,32 @@ fn aiur_fn_655( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_27]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_27]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_656: usize = 11; -const IN_656: usize = 11; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_660: usize = 11; +const IN_660: usize = 11; +const OUT_660: usize = 1; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], 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]; @@ -55409,28 +55830,28 @@ fn aiur_fn_656( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -55447,16 +55868,16 @@ fn aiur_fn_656( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); @@ -55470,13 +55891,13 @@ fn aiur_fn_656( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -55484,7 +55905,7 @@ fn aiur_fn_656( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -55496,7 +55917,7 @@ fn aiur_fn_656( let __v_64: G = G::from_u64(0); let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); @@ -55508,16 +55929,16 @@ fn aiur_fn_656( let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_81]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_81]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55527,15 +55948,15 @@ fn aiur_fn_656( }) } -const INPUT_SIZE_657: usize = 26; -const IN_657: usize = 26; -const OUT_657: usize = 0; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_661: usize = 26; +const IN_661: usize = 26; +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_657], 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]; @@ -55570,7 +55991,7 @@ fn aiur_fn_657( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -55621,11 +56042,11 @@ fn aiur_fn_657( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_43: G = __r_arr[0]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { @@ -55645,17 +56066,17 @@ fn aiur_fn_657( }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; @@ -55665,7 +56086,7 @@ fn aiur_fn_657( let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, @@ -55679,26 +56100,26 @@ fn aiur_fn_657( }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55709,8 +56130,8 @@ fn aiur_fn_657( } }, _ => { - let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55722,15 +56143,15 @@ fn aiur_fn_657( }) } -const INPUT_SIZE_658: usize = 18; -const IN_658: usize = 18; -const OUT_658: usize = 0; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_662: usize = 18; +const IN_662: usize = 18; +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_658], 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]; @@ -55750,29 +56171,29 @@ fn aiur_fn_658( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { @@ -55785,22 +56206,22 @@ fn aiur_fn_658( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_658] = []; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_662] = []; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_659: usize = 3; -const IN_659: usize = 3; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_663: usize = 3; +const IN_663: usize = 3; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], 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]; @@ -55809,8 +56230,8 @@ fn aiur_fn_659( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_659] = [__v_4]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_4]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55824,12 +56245,12 @@ fn aiur_fn_659( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_659] = [__v_10]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_10]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -55857,11 +56278,11 @@ fn aiur_fn_659( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_27]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55873,15 +56294,15 @@ fn aiur_fn_659( }) } -const INPUT_SIZE_660: usize = 15; -const IN_660: usize = 15; -const OUT_660: usize = 1; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_664: usize = 15; +const IN_664: usize = 15; +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_660], 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]; @@ -55904,12 +56325,12 @@ fn aiur_fn_660( 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_660] = [__v_18]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_18]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -55927,24 +56348,24 @@ fn aiur_fn_660( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_660] = [__v_35]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_35]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_660] = [__v_31]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_31]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55953,15 +56374,15 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 9; -const IN_661: usize = 9; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_665: usize = 9; +const IN_665: usize = 9; +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_661], 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]; @@ -55980,14 +56401,14 @@ fn aiur_fn_661( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56028,8 +56449,8 @@ fn aiur_fn_661( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -56040,7 +56461,7 @@ fn aiur_fn_661( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -56050,7 +56471,7 @@ fn aiur_fn_661( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -56058,9 +56479,9 @@ fn aiur_fn_661( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56077,15 +56498,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 12; -const IN_662: usize = 12; -const OUT_662: usize = 1; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_666: usize = 12; +const IN_666: usize = 12; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], 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]; @@ -56105,13 +56526,13 @@ fn aiur_fn_662( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_662] = [__v_0]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_0]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -56146,27 +56567,27 @@ fn aiur_fn_662( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); @@ -56175,32 +56596,32 @@ fn aiur_fn_662( let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56210,22 +56631,22 @@ fn aiur_fn_662( let __v_97: G = G::from_u64(0); let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_662] = [__v_110]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_110]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56235,15 +56656,15 @@ fn aiur_fn_662( }) } -const INPUT_SIZE_663: usize = 13; -const IN_663: usize = 13; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_667: usize = 13; +const IN_667: usize = 13; +const OUT_667: usize = 1; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], 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]; @@ -56258,19 +56679,19 @@ fn aiur_fn_663( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); @@ -56283,7 +56704,7 @@ fn aiur_fn_663( let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56297,26 +56718,26 @@ fn aiur_fn_663( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_663] = [__v_49]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_49]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_664: usize = 3; -const IN_664: usize = 3; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_668: usize = 3; +const IN_668: usize = 3; +const OUT_668: usize = 1; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], 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]; @@ -56333,19 +56754,19 @@ fn aiur_fn_664( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_11]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_11]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_12]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_12]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56355,22 +56776,22 @@ fn aiur_fn_664( }) } -const INPUT_SIZE_665: usize = 5; -const IN_665: usize = 5; -const OUT_665: usize = 1; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_669: usize = 5; +const IN_669: usize = 5; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], ExecError> { +) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -56424,15 +56845,15 @@ fn aiur_fn_665( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_665] = [__v_54]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_54]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_665] = [__v_4]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_4]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56441,15 +56862,15 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 8; -const IN_666: usize = 8; -const OUT_666: usize = 1; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_670: usize = 8; +const IN_670: usize = 8; +const OUT_670: usize = 1; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], 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]; @@ -56509,16 +56930,16 @@ fn aiur_fn_666( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_666] = [__v_6]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_6]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -56535,9 +56956,9 @@ fn aiur_fn_666( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; @@ -56573,9 +56994,9 @@ fn aiur_fn_666( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -56596,17 +57017,17 @@ fn aiur_fn_666( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_666] = [__v_55]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_55]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_72]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_72]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56614,10 +57035,10 @@ fn aiur_fn_666( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_57]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_57]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56629,15 +57050,15 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 1; -const IN_667: usize = 1; -const OUT_667: usize = 1; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_671: usize = 1; +const IN_671: usize = 1; +const OUT_671: usize = 1; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], ExecError> { +) -> Result<[G; OUT_671], 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 }; @@ -56652,12 +57073,12 @@ fn aiur_fn_667( 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_667] = [__v_9]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_9]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -56684,11 +57105,11 @@ fn aiur_fn_667( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_667] = [__v_23]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_23]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56698,20 +57119,20 @@ fn aiur_fn_667( }) } -const INPUT_SIZE_668: usize = 3; -const IN_668: usize = 3; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_672: usize = 3; +const IN_672: usize = 3; +const OUT_672: usize = 1; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], ExecError> { +) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -56720,7 +57141,7 @@ fn aiur_fn_668( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -56743,25 +57164,25 @@ fn aiur_fn_668( let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_668] = [__v_34]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_34]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_669: usize = 15; -const IN_669: usize = 15; -const OUT_669: usize = 1; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_673: usize = 15; +const IN_673: usize = 15; +const OUT_673: usize = 1; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], 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]; @@ -56784,12 +57205,12 @@ fn aiur_fn_669( 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_669] = [__v_18]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_18]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -56806,20 +57227,20 @@ fn aiur_fn_669( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_669] = [__v_37]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_37]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56831,15 +57252,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 5; -const IN_670: usize = 5; -const OUT_670: usize = 1; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_674: usize = 5; +const IN_674: usize = 5; +const OUT_674: usize = 1; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -56848,23 +57269,23 @@ fn aiur_fn_670( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_7]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_7]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_671: usize = 8; -const IN_671: usize = 8; -const OUT_671: usize = 1; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_675: usize = 8; +const IN_675: usize = 8; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], 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]; @@ -56886,12 +57307,12 @@ fn aiur_fn_671( 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_671] = [__v_16]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_16]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56909,28 +57330,28 @@ fn aiur_fn_671( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_671] = [__v_34]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_34]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_671] = [__v_29]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_29]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56942,15 +57363,15 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 5; -const IN_672: usize = 5; -const OUT_672: usize = 1; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_676: usize = 5; +const IN_676: usize = 5; +const OUT_676: usize = 1; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56965,23 +57386,23 @@ fn aiur_fn_672( let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_672] = [__v_10]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_10]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_672] = [__v_9]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_9]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56991,8 +57412,8 @@ fn aiur_fn_672( let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_672] = [__v_12]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_12]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57001,15 +57422,15 @@ fn aiur_fn_672( }) } -const INPUT_SIZE_673: usize = 2; -const IN_673: usize = 2; -const OUT_673: usize = 1; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +const OUT_677: usize = 1; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], 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]; @@ -57022,30 +57443,30 @@ fn aiur_fn_673( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_673] = [__v_8]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_8]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_673] = [__v_1]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_1]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_674: usize = 7; -const IN_674: usize = 7; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_678: usize = 7; +const IN_678: usize = 7; +const OUT_678: usize = 1; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], 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]; @@ -57056,8 +57477,8 @@ fn aiur_fn_674( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_674] = [__v_0]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_0]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57068,26 +57489,26 @@ fn aiur_fn_674( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_18]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_18]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57096,19 +57517,19 @@ fn aiur_fn_674( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_26]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_26]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57122,15 +57543,15 @@ fn aiur_fn_674( }) } -const INPUT_SIZE_675: usize = 13; -const IN_675: usize = 13; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_679: usize = 13; +const IN_679: usize = 13; +const OUT_679: usize = 1; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], ExecError> { +) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57145,13 +57566,13 @@ fn aiur_fn_675( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -57163,24 +57584,24 @@ fn aiur_fn_675( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -57189,66 +57610,66 @@ fn aiur_fn_675( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_62]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_62]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_676: usize = 1; -const IN_676: usize = 1; -const OUT_676: usize = 2; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_680: usize = 1; +const IN_680: usize = 1; +const OUT_680: usize = 2; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_680], 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_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_676] = [__v_6, __v_5]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_6, __v_5]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 2; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_681: usize = 2; +const IN_681: usize = 2; +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_677], 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]; @@ -57261,31 +57682,31 @@ fn aiur_fn_677( 5u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_677] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_677] = [__v_1, __v_0]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_1, __v_0]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_678: usize = 8; -const IN_678: usize = 8; -const OUT_678: usize = 1; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_682: usize = 8; +const IN_682: usize = 8; +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_678], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57304,30 +57725,30 @@ fn aiur_fn_678( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_678] = [__v_13]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_13]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -57341,37 +57762,37 @@ fn aiur_fn_678( let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_678] = [__v_58]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_58]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57381,15 +57802,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 3; -const IN_679: usize = 3; -const OUT_679: usize = 1; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_683: usize = 3; +const IN_683: usize = 3; +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_679], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57403,19 +57824,19 @@ fn aiur_fn_679( 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_679] = [__v_8]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_8]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __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_679] = [__v_9]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_9]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57425,15 +57846,15 @@ fn aiur_fn_679( }) } -const INPUT_SIZE_680: usize = 4; -const IN_680: usize = 4; -const OUT_680: usize = 1; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_684: usize = 4; +const IN_684: usize = 4; +const OUT_684: usize = 1; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], 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]; @@ -57442,8 +57863,8 @@ fn aiur_fn_680( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_680] = [__v_0]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_0]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57458,25 +57879,25 @@ fn aiur_fn_680( 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_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_680] = [__v_16]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_16]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_681: usize = 6; -const IN_681: usize = 6; -const OUT_681: usize = 1; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_685: usize = 6; +const IN_685: usize = 6; +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_681], 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]; @@ -57489,55 +57910,55 @@ fn aiur_fn_681( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_681] = [__v_9]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_9]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_681] = [__v_7]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_7]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_682: usize = 3; -const IN_682: usize = 3; -const OUT_682: usize = 2; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_686: usize = 3; +const IN_686: usize = 3; +const OUT_686: usize = 2; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], 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]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_682] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_683: usize = 3; -const IN_683: usize = 3; -const OUT_683: usize = 2; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_687: usize = 3; +const IN_687: usize = 3; +const OUT_687: usize = 2; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], 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]; @@ -57545,7 +57966,7 @@ fn aiur_fn_683( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -57554,15 +57975,15 @@ fn aiur_fn_683( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_683] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -57573,18 +57994,18 @@ fn aiur_fn_683( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_683] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_683] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57593,15 +58014,15 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 5; -const IN_684: usize = 5; -const OUT_684: usize = 2; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_688: usize = 5; +const IN_688: usize = 5; +const OUT_688: usize = 2; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], 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]; @@ -57619,8 +58040,8 @@ fn aiur_fn_684( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_684] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57632,7 +58053,7 @@ fn aiur_fn_684( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -57643,18 +58064,18 @@ fn aiur_fn_684( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_684] = [__v_14, __v_4]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_14, __v_4]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_684] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57666,15 +58087,15 @@ fn aiur_fn_684( }) } -const INPUT_SIZE_685: usize = 3; -const IN_685: usize = 3; -const OUT_685: usize = 1; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_689: usize = 3; +const IN_689: usize = 3; +const OUT_689: usize = 1; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], 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]; @@ -57686,8 +58107,8 @@ fn aiur_fn_685( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_685] = [__v_6]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_6]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57698,28 +58119,28 @@ fn aiur_fn_685( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_685] = [__v_9]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_9]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_12]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_12]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_685] = [__v_12]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_12]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57736,15 +58157,15 @@ fn aiur_fn_685( }) } -const INPUT_SIZE_686: usize = 7; -const IN_686: usize = 7; -const OUT_686: usize = 4; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_690: usize = 7; +const IN_690: usize = 7; +const OUT_690: usize = 4; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], 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]; @@ -57761,7 +58182,7 @@ fn aiur_fn_686( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); @@ -57774,53 +58195,53 @@ fn aiur_fn_686( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_686] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_686] = [__v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_686] = [__v_11, __v_12, __v_13, __v_0]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_11, __v_12, __v_13, __v_0]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_687: usize = 4; -const IN_687: usize = 4; -const OUT_687: usize = 1; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_691: usize = 4; +const IN_691: usize = 4; +const OUT_691: usize = 1; +fn aiur_fn_691( + inp: [G; IN_691], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], 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]; @@ -57838,12 +58259,12 @@ fn aiur_fn_687( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_687] = [__v_12]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_12]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -57860,26 +58281,26 @@ fn aiur_fn_687( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_687] = [__v_30]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_30]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_687] = [__v_23]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_23]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57891,15 +58312,15 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 13; -const IN_688: usize = 13; -const OUT_688: usize = 0; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_692: usize = 13; +const IN_692: usize = 13; +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_688], 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]; @@ -57916,9 +58337,9 @@ fn aiur_fn_688( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57935,9 +58356,9 @@ fn aiur_fn_688( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; @@ -57950,11 +58371,11 @@ fn aiur_fn_688( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -57967,15 +58388,15 @@ fn aiur_fn_688( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -57983,9 +58404,9 @@ fn aiur_fn_688( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_688] = []; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_692] = []; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58000,15 +58421,15 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 6; -const IN_689: usize = 6; -const OUT_689: usize = 0; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_693: usize = 6; +const IN_693: usize = 6; +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_689], 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]; @@ -58019,7 +58440,7 @@ fn aiur_fn_689( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -58028,16 +58449,16 @@ fn aiur_fn_689( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } - let __ret: [G; OUT_689] = []; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58047,15 +58468,15 @@ fn aiur_fn_689( }) } -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_694: usize = 2; +const IN_694: usize = 2; +const OUT_694: usize = 1; +fn aiur_fn_694( + inp: [G; IN_694], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], 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]; @@ -58065,8 +58486,8 @@ fn aiur_fn_690( 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_690] = [__v_5]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_694] = [__v_5]; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58076,26 +58497,26 @@ fn aiur_fn_690( 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_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __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_690] = [__v_10]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_694] = [__v_10]; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -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_695: usize = 3; +const IN_695: usize = 3; +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_691], 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]; @@ -58108,18 +58529,18 @@ fn aiur_fn_691( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = []; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_695] = []; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58131,15 +58552,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 4; -const IN_692: usize = 4; -const OUT_692: usize = 3; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_696: usize = 4; +const IN_696: usize = 4; +const OUT_696: usize = 3; +fn aiur_fn_696( + inp: [G; IN_696], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], 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]; @@ -58147,8 +58568,8 @@ fn aiur_fn_692( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58165,17 +58586,17 @@ fn aiur_fn_692( let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_692] = [__v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58184,15 +58605,15 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 13; -const IN_693: usize = 13; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_697: usize = 13; +const IN_697: usize = 13; +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_693], 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]; @@ -58207,58 +58628,58 @@ fn aiur_fn_693( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58267,71 +58688,71 @@ fn aiur_fn_693( let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -58348,15 +58769,15 @@ fn aiur_fn_693( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -58365,14 +58786,14 @@ fn aiur_fn_693( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58384,17 +58805,17 @@ fn aiur_fn_693( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58404,18 +58825,18 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 1; -const IN_694: usize = 1; -const OUT_694: usize = 0; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_698: usize = 1; +const IN_698: usize = 1; +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_694], ExecError> { +) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -58430,22 +58851,22 @@ fn aiur_fn_694( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_694] = []; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_695: usize = 1; -const IN_695: usize = 1; -const OUT_695: usize = 1; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_699: usize = 1; +const IN_699: usize = 1; +const OUT_699: usize = 1; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_695], ExecError> { +) -> Result<[G; OUT_699], 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 }; @@ -58476,90 +58897,90 @@ fn aiur_fn_695( let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_695] = [__v_24]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_24]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_695] = [__v_22]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_22]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_695] = [__v_23]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_23]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_696: usize = 1; -const IN_696: usize = 1; -const OUT_696: usize = 1; -fn aiur_fn_696( - inp: [G; IN_696], +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_696], ExecError> { +) -> Result<[G; OUT_700], 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 }; @@ -58571,19 +58992,19 @@ fn aiur_fn_696( 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_696] = [__v_6]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_6]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_696] = [__v_6]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_6]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58593,15 +59014,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_701: usize = 1; +const IN_701: usize = 1; +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_697], ExecError> { +) -> Result<[G; OUT_701], 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 }; @@ -58621,21 +59042,21 @@ fn aiur_fn_697( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_697] = [__v_14]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_14]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_697] = [__v_14]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_14]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58647,15 +59068,15 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 1; -const IN_698: usize = 1; -const OUT_698: usize = 1; -fn aiur_fn_698( - inp: [G; IN_698], +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_698], ExecError> { +) -> Result<[G; OUT_702], 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 }; @@ -58700,21 +59121,21 @@ fn aiur_fn_698( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_698] = [__v_39]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_702] = [__v_39]; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_698] = [__v_39]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_702] = [__v_39]; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58726,15 +59147,15 @@ fn aiur_fn_698( }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 1; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_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_699], ExecError> { +) -> Result<[G; OUT_703], 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 }; @@ -58790,8 +59211,8 @@ fn aiur_fn_699( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_50]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_50]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -58799,18 +59220,18 @@ fn aiur_fn_699( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58818,18 +59239,18 @@ fn aiur_fn_699( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58837,18 +59258,18 @@ fn aiur_fn_699( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58865,15 +59286,15 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 48; -const IN_700: usize = 48; -const OUT_700: usize = 1; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_704: usize = 48; +const IN_704: usize = 48; +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_700], 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]; @@ -58925,22 +59346,22 @@ fn aiur_fn_700( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_52]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_52]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58948,16 +59369,16 @@ fn aiur_fn_700( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_52]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_52]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58965,12 +59386,12 @@ fn aiur_fn_700( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58978,28 +59399,28 @@ fn aiur_fn_700( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_700] = [__v_48]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_48]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59008,15 +59429,15 @@ fn aiur_fn_700( }) } -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_705: usize = 2; +const IN_705: usize = 2; +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_701], 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]; @@ -59027,8 +59448,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]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_5]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -59036,15 +59457,15 @@ fn aiur_fn_701( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_701] = [__v_6]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_6]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_701] = [__v_6]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_6]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59056,18 +59477,18 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 0; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_706: usize = 1; +const IN_706: usize = 1; +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_702], ExecError> { +) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -59121,14 +59542,14 @@ fn aiur_fn_702( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59136,8 +59557,8 @@ fn aiur_fn_702( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59145,8 +59566,8 @@ fn aiur_fn_702( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59154,39 +59575,39 @@ fn aiur_fn_702( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_702] = []; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_703: usize = 3; -const IN_703: usize = 3; -const OUT_703: usize = 0; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_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_703], 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]; @@ -59197,16 +59618,16 @@ fn aiur_fn_703( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_703] = []; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_707] = []; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -59216,9 +59637,9 @@ fn aiur_fn_703( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_703] = []; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59228,15 +59649,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 4; -const IN_704: usize = 4; -const OUT_704: usize = 0; -fn aiur_fn_704( - inp: [G; IN_704], +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_704], 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]; @@ -59292,17 +59713,17 @@ fn aiur_fn_704( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_704] = []; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = []; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_704] = []; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59312,15 +59733,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 48; -const IN_705: usize = 48; -const OUT_705: usize = 0; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_709: usize = 48; +const IN_709: usize = 48; +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_705], 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]; @@ -59370,9 +59791,9 @@ fn aiur_fn_705( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -59387,98 +59808,98 @@ fn aiur_fn_705( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_705] = []; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_709] = []; + if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 1; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_710: usize = 1; +const IN_710: usize = 1; +const OUT_710: usize = 1; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_710], 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_46] = { let __args: [G; IN_46] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_706] = [__v_8]; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_8]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_707: usize = 2; -const IN_707: usize = 2; -const OUT_707: usize = 1; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_711: usize = 2; +const IN_711: usize = 2; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], 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 __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_46] = { let __args: [G; IN_46] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_707] = [__v_10]; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_711] = [__v_10]; + if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_708: usize = 1; -const IN_708: usize = 1; -const OUT_708: usize = 3; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 3; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __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_708] = [__v_5, __v_10, __v_4]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_5, __v_10, __v_4]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -59518,25 +59939,25 @@ fn aiur_fn_708( 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_708] = [__v_35, __v_38, __v_2]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_35, __v_38, __v_2]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_708] = [__v_9, __v_10, __v_8]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_9, __v_10, __v_8]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59546,15 +59967,15 @@ fn aiur_fn_708( }) } -const INPUT_SIZE_709: usize = 1; -const IN_709: usize = 1; -const OUT_709: usize = 1; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_713: usize = 1; +const IN_713: usize = 1; +const OUT_713: usize = 1; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_713], 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 }; @@ -59597,7 +60018,7 @@ fn aiur_fn_709( let __v_36: G = G::from_u64(1); let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -59608,7 +60029,7 @@ fn aiur_fn_709( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -59764,21 +60185,21 @@ fn aiur_fn_709( if (__v_82 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } - let __ret: [G; OUT_709] = [__v_49]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_713] = [__v_49]; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_710: usize = 7; -const IN_710: usize = 7; -const OUT_710: usize = 6; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_714: usize = 7; +const IN_714: usize = 7; +const OUT_714: usize = 6; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], 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]; @@ -59793,28 +60214,28 @@ fn aiur_fn_710( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __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_710] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59824,15 +60245,15 @@ fn aiur_fn_710( }) } -const INPUT_SIZE_711: usize = 7; -const IN_711: usize = 7; -const OUT_711: usize = 1; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_715: usize = 7; +const IN_715: usize = 7; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], 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]; @@ -59842,23 +60263,23 @@ fn aiur_fn_711( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_711] = [__v_8]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_715] = [__v_8]; + if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_712: usize = 14; -const IN_712: usize = 14; -const OUT_712: usize = 0; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_716: usize = 14; +const IN_716: usize = 14; +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_712], 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]; @@ -59874,18 +60295,18 @@ fn aiur_fn_712( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = []; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -59898,7 +60319,7 @@ fn aiur_fn_712( }, } }; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -59952,14 +60373,14 @@ fn aiur_fn_712( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59967,8 +60388,8 @@ fn aiur_fn_712( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59976,8 +60397,8 @@ fn aiur_fn_712( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59985,24 +60406,24 @@ fn aiur_fn_712( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_716] = []; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -60011,15 +60432,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 16; -const IN_713: usize = 16; -const OUT_713: usize = 0; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_717: usize = 16; +const IN_717: usize = 16; +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_713], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60043,16 +60464,16 @@ fn aiur_fn_713( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = []; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -60062,9 +60483,9 @@ fn aiur_fn_713( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_717] = []; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60074,15 +60495,15 @@ fn aiur_fn_713( }) } -const INPUT_SIZE_714: usize = 13; -const IN_714: usize = 13; -const OUT_714: usize = 0; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_718: usize = 13; +const IN_718: usize = 13; +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_714], 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]; @@ -60103,16 +60524,16 @@ fn aiur_fn_714( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = []; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_718] = []; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60122,20 +60543,20 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 3; -const IN_715: usize = 3; -const OUT_715: usize = 0; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_719: usize = 3; +const IN_719: usize = 3; +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_715], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { @@ -60145,7 +60566,7 @@ fn aiur_fn_715( break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -60157,7 +60578,7 @@ fn aiur_fn_715( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -60166,49 +60587,49 @@ fn aiur_fn_715( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_715] = []; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_719] = []; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 1; -const IN_716: usize = 1; -const OUT_716: usize = 3; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_720: usize = 1; +const IN_720: usize = 1; +const OUT_720: usize = 3; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_716] = [__v_3, __v_4, __v_2]; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_3, __v_4, __v_2]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_716] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_5, __v_3, __v_4]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60218,15 +60639,15 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 2; -const IN_717: usize = 2; -const OUT_717: usize = 10; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_721: usize = 2; +const IN_721: usize = 2; +const OUT_721: usize = 10; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], 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]; @@ -60234,12 +60655,12 @@ fn aiur_fn_717( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_717] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60250,23 +60671,23 @@ fn aiur_fn_717( 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_717] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_718: usize = 2; -const IN_718: usize = 2; -const OUT_718: usize = 3; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_722: usize = 2; +const IN_722: usize = 2; +const OUT_722: usize = 3; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], 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]; @@ -60274,32 +60695,32 @@ fn aiur_fn_718( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_718] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_719: usize = 2; -const IN_719: usize = 2; -const OUT_719: usize = 3; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_723: usize = 2; +const IN_723: usize = 2; +const OUT_723: usize = 3; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], 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]; @@ -60307,32 +60728,32 @@ fn aiur_fn_719( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_719] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_720: usize = 2; -const IN_720: usize = 2; -const OUT_720: usize = 3; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_724: usize = 2; +const IN_724: usize = 2; +const OUT_724: usize = 3; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], 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]; @@ -60340,34 +60761,34 @@ fn aiur_fn_720( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_720] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60379,15 +60800,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 3; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_725: usize = 2; +const IN_725: usize = 2; +const OUT_725: usize = 3; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], 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]; @@ -60395,41 +60816,41 @@ fn aiur_fn_721( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60441,15 +60862,15 @@ fn aiur_fn_721( }) } -const INPUT_SIZE_722: usize = 9; -const IN_722: usize = 9; -const OUT_722: usize = 2; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_726: usize = 9; +const IN_726: usize = 9; +const OUT_726: usize = 2; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], 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]; @@ -60467,12 +60888,12 @@ fn aiur_fn_722( 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_722] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60500,28 +60921,28 @@ fn aiur_fn_722( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __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_722] = [__v_39, __v_37]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_39, __v_37]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 3; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 3; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], 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]; @@ -60529,12 +60950,12 @@ fn aiur_fn_723( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60544,30 +60965,30 @@ fn aiur_fn_723( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_723] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_724: usize = 1; -const IN_724: usize = 1; -const OUT_724: usize = 41; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; +const OUT_728: usize = 41; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60586,11 +61007,11 @@ fn aiur_fn_724( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -60601,7 +61022,7 @@ fn aiur_fn_724( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -60612,7 +61033,7 @@ fn aiur_fn_724( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -60623,7 +61044,7 @@ fn aiur_fn_724( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -60634,28 +61055,28 @@ fn aiur_fn_724( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_724] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_725: usize = 1; -const IN_725: usize = 1; -const OUT_725: usize = 49; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 49; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60665,7 +61086,7 @@ fn aiur_fn_725( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60707,21 +61128,21 @@ fn aiur_fn_725( 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_725] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_726: usize = 9; -const IN_726: usize = 9; -const OUT_726: usize = 2; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_730: usize = 9; +const IN_730: usize = 9; +const OUT_730: usize = 2; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], 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]; @@ -60739,12 +61160,12 @@ fn aiur_fn_726( 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_726] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60803,28 +61224,28 @@ fn aiur_fn_726( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __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_726] = [__v_70, __v_68]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_70, __v_68]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 3; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +const OUT_731: usize = 3; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], 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]; @@ -60832,12 +61253,12 @@ fn aiur_fn_727( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60847,33 +61268,33 @@ fn aiur_fn_727( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 55; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 55; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -60903,15 +61324,15 @@ fn aiur_fn_728( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -60922,26 +61343,26 @@ fn aiur_fn_728( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_728] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -60952,7 +61373,7 @@ fn aiur_fn_728( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -60963,7 +61384,7 @@ fn aiur_fn_728( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -60974,30 +61395,30 @@ fn aiur_fn_728( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); - let __ret: [G; OUT_728] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61008,7 +61429,7 @@ fn aiur_fn_728( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61019,7 +61440,7 @@ fn aiur_fn_728( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61030,7 +61451,7 @@ fn aiur_fn_728( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61041,7 +61462,7 @@ fn aiur_fn_728( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61052,17 +61473,17 @@ fn aiur_fn_728( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); - let __ret: [G; OUT_728] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61072,18 +61493,18 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 63; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 63; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_733], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -61093,7 +61514,7 @@ fn aiur_fn_729( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61149,21 +61570,21 @@ fn aiur_fn_729( 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_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 9; -const IN_730: usize = 9; -const OUT_730: usize = 2; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_734: usize = 9; +const IN_734: usize = 9; +const OUT_734: usize = 2; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], 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]; @@ -61181,12 +61602,12 @@ fn aiur_fn_730( 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_730] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61259,34 +61680,34 @@ fn aiur_fn_730( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __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_730] = [__v_84, __v_82]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = [__v_84, __v_82]; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_731: usize = 1; -const IN_731: usize = 1; -const OUT_731: usize = 55; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_735: usize = 1; +const IN_735: usize = 1; +const OUT_735: usize = 55; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -61316,15 +61737,15 @@ fn aiur_fn_731( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61335,30 +61756,30 @@ fn aiur_fn_731( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61369,7 +61790,7 @@ fn aiur_fn_731( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61380,7 +61801,7 @@ fn aiur_fn_731( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61391,7 +61812,7 @@ fn aiur_fn_731( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61402,7 +61823,7 @@ fn aiur_fn_731( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61413,25 +61834,25 @@ fn aiur_fn_731( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); - let __ret: [G; OUT_731] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61442,22 +61863,22 @@ fn aiur_fn_731( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61468,18 +61889,18 @@ fn aiur_fn_731( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61490,7 +61911,7 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -61501,18 +61922,18 @@ fn aiur_fn_731( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61523,18 +61944,18 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61545,18 +61966,18 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61567,14 +61988,14 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -61586,7 +62007,7 @@ fn aiur_fn_731( break '__mc_0 [__v_30, __v_11]; }, 1u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61596,7 +62017,7 @@ fn aiur_fn_731( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -61610,8 +62031,8 @@ fn aiur_fn_731( 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_731] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61621,15 +62042,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_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_732], ExecError> { +) -> Result<[G; OUT_736], 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 }; @@ -61658,40 +62079,40 @@ fn aiur_fn_732( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_732] = [__v_23]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = [__v_23]; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 1; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_737: usize = 1; +const IN_737: usize = 1; +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_733], ExecError> { +) -> Result<[G; OUT_737], 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_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61701,35 +62122,35 @@ fn aiur_fn_733( }) } -const INPUT_SIZE_734: usize = 3; -const IN_734: usize = 3; -const OUT_734: usize = 0; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_738: usize = 3; +const IN_738: usize = 3; +const OUT_738: usize = 0; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_734] = []; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } - let __ret: [G; OUT_734] = []; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61739,35 +62160,35 @@ fn aiur_fn_734( }) } -const INPUT_SIZE_735: usize = 3; -const IN_735: usize = 3; -const OUT_735: usize = 0; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_739: usize = 3; +const IN_739: usize = 3; +const OUT_739: usize = 0; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_739], ExecError> { stacker::maybe_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_735] = []; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } - let __ret: [G; OUT_735] = []; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61777,35 +62198,35 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 3; -const IN_736: usize = 3; -const OUT_736: usize = 0; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_740: usize = 3; +const IN_740: usize = 3; +const OUT_740: usize = 0; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_736] = []; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } - let __ret: [G; OUT_736] = []; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61815,31 +62236,31 @@ fn aiur_fn_736( }) } -const INPUT_SIZE_737: usize = 3; -const IN_737: usize = 3; -const OUT_737: usize = 0; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_741: usize = 3; +const IN_741: usize = 3; +const OUT_741: usize = 0; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_737] = []; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } - let __ret: [G; OUT_737] = []; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61849,15 +62270,15 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 17; -const IN_738: usize = 17; -const OUT_738: usize = 0; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_742: usize = 17; +const IN_742: usize = 17; +const OUT_742: usize = 0; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61878,8 +62299,8 @@ fn aiur_fn_738( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -61907,8 +62328,8 @@ fn aiur_fn_738( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61918,23 +62339,23 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 3; -const IN_739: usize = 3; -const OUT_739: usize = 0; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_743: usize = 3; +const IN_743: usize = 3; +const OUT_743: usize = 0; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], 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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62100,8 +62521,8 @@ fn aiur_fn_739( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62111,27 +62532,27 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 3; -const IN_740: usize = 3; -const OUT_740: usize = 0; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_744: usize = 3; +const IN_744: usize = 3; +const OUT_744: usize = 0; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __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]; @@ -62295,8 +62716,8 @@ fn aiur_fn_740( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62306,15 +62727,15 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 10; -const IN_741: usize = 10; -const OUT_741: usize = 0; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_745: usize = 10; +const IN_745: usize = 10; +const OUT_745: usize = 0; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], 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]; @@ -62362,8 +62783,8 @@ fn aiur_fn_741( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62391,7 +62812,7 @@ fn aiur_fn_741( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -62449,9 +62870,9 @@ fn aiur_fn_741( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62470,23 +62891,23 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 3; -const IN_742: usize = 3; -const OUT_742: usize = 0; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_746: usize = 3; +const IN_746: usize = 3; +const OUT_746: usize = 0; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62498,9 +62919,9 @@ fn aiur_fn_742( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62510,15 +62931,15 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 49; -const IN_743: usize = 49; -const OUT_743: usize = 0; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_747: usize = 49; +const IN_747: usize = 49; +const OUT_747: usize = 0; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], 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]; @@ -62569,7 +62990,7 @@ fn aiur_fn_743( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -62608,14 +63029,14 @@ fn aiur_fn_743( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62624,15 +63045,15 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 2; -const IN_744: usize = 2; -const OUT_744: usize = 0; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_748: usize = 2; +const IN_748: usize = 2; +const OUT_748: usize = 0; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], 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]; @@ -62689,15 +63110,15 @@ fn aiur_fn_744( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62707,29 +63128,29 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 3; -const IN_745: usize = 3; -const OUT_745: usize = 0; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_749: usize = 3; +const IN_749: usize = 3; +const OUT_749: usize = 0; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62739,15 +63160,15 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 99; -const IN_746: usize = 99; -const OUT_746: usize = 0; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_750: usize = 99; +const IN_750: usize = 99; +const OUT_750: usize = 0; +fn aiur_fn_750( + inp: [G; IN_750], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], 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]; @@ -62854,13 +63275,13 @@ fn aiur_fn_746( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62875,14 +63296,14 @@ fn aiur_fn_746( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62897,17 +63318,17 @@ fn aiur_fn_746( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62924,15 +63345,15 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 2; -const IN_747: usize = 2; -const OUT_747: usize = 0; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_751: usize = 2; +const IN_751: usize = 2; +const OUT_751: usize = 0; +fn aiur_fn_751( + inp: [G; IN_751], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], 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]; @@ -63003,12 +63424,12 @@ fn aiur_fn_747( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -63054,10 +63475,10 @@ fn aiur_fn_747( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { 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 __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63067,15 +63488,15 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 55; -const IN_748: usize = 55; -const OUT_748: usize = 0; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_752: usize = 55; +const IN_752: usize = 55; +const OUT_752: usize = 0; +fn aiur_fn_752( + inp: [G; IN_752], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], 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]; @@ -63132,7 +63553,7 @@ fn aiur_fn_748( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -63189,13 +63610,13 @@ fn aiur_fn_748( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63210,17 +63631,17 @@ fn aiur_fn_748( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63235,11 +63656,11 @@ fn aiur_fn_748( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63254,11 +63675,11 @@ fn aiur_fn_748( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_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[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63273,11 +63694,11 @@ fn aiur_fn_748( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63292,10 +63713,10 @@ fn aiur_fn_748( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63310,10 +63731,10 @@ fn aiur_fn_748( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63328,10 +63749,10 @@ fn aiur_fn_748( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63344,9 +63765,9 @@ fn aiur_fn_748( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { 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 __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63363,41 +63784,41 @@ fn aiur_fn_748( }) } -const INPUT_SIZE_749: usize = 2; -const IN_749: usize = 2; -const OUT_749: usize = 0; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_753: usize = 2; +const IN_753: usize = 2; +const OUT_753: usize = 0; +fn aiur_fn_753( + inp: [G; IN_753], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } - let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = []; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_750: usize = 8; -const IN_750: usize = 8; -const OUT_750: usize = 0; -fn aiur_fn_750( - inp: [G; IN_750], +const INPUT_SIZE_754: usize = 8; +const IN_754: usize = 8; +const OUT_754: usize = 0; +fn aiur_fn_754( + inp: [G; IN_754], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_750], ExecError> { +) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63499,7 +63920,7 @@ fn aiur_fn_750( let __v_93: G = __r_arr[29]; let __v_94: G = __r_arr[30]; let __v_95: G = __r_arr[31]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -63622,26 +64043,26 @@ fn aiur_fn_750( } match __v_97.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -63651,9 +64072,9 @@ fn aiur_fn_750( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63662,23 +64083,23 @@ fn aiur_fn_750( } }, 5u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -63734,21 +64155,21 @@ fn aiur_fn_750( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63758,15 +64179,15 @@ fn aiur_fn_750( }) } -const INPUT_SIZE_751: usize = 8; -const IN_751: usize = 8; -const OUT_751: usize = 0; -fn aiur_fn_751( - inp: [G; IN_751], +const INPUT_SIZE_755: usize = 8; +const IN_755: usize = 8; +const OUT_755: usize = 0; +fn aiur_fn_755( + inp: [G; IN_755], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_751], ExecError> { +) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63776,27 +64197,27 @@ fn aiur_fn_751( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_755] = []; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_752: usize = 3; -const IN_752: usize = 3; -const OUT_752: usize = 1; -fn aiur_fn_752( - inp: [G; IN_752], +const INPUT_SIZE_756: usize = 3; +const IN_756: usize = 3; +const OUT_756: usize = 1; +fn aiur_fn_756( + inp: [G; IN_756], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_752], ExecError> { +) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -63804,13 +64225,13 @@ fn aiur_fn_752( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_752] = [__v_2]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_2]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_752] = [__v_5]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_5]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63820,15 +64241,15 @@ fn aiur_fn_752( }) } -const INPUT_SIZE_753: usize = 2; -const IN_753: usize = 2; -const OUT_753: usize = 1; -fn aiur_fn_753( - inp: [G; IN_753], +const INPUT_SIZE_757: usize = 2; +const IN_757: usize = 2; +const OUT_757: usize = 1; +fn aiur_fn_757( + inp: [G; IN_757], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_753], ExecError> { +) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63843,17 +64264,17 @@ fn aiur_fn_753( 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_753] = [__v_9]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_9]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __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_753] = [__v_7]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_7]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63863,15 +64284,15 @@ fn aiur_fn_753( }) } -const INPUT_SIZE_754: usize = 1; -const IN_754: usize = 1; -const OUT_754: usize = 8; -fn aiur_fn_754( - inp: [G; IN_754], +const INPUT_SIZE_758: usize = 1; +const IN_758: usize = 1; +const OUT_758: usize = 8; +fn aiur_fn_758( + inp: [G; IN_758], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_754], ExecError> { +) -> Result<[G; OUT_758], 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 }; @@ -63895,12 +64316,12 @@ fn aiur_fn_754( 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_754] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -63918,8 +64339,8 @@ fn aiur_fn_754( 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_754] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63929,15 +64350,15 @@ fn aiur_fn_754( }) } -const INPUT_SIZE_755: usize = 2; -const IN_755: usize = 2; -const OUT_755: usize = 1; -fn aiur_fn_755( - inp: [G; IN_755], +const INPUT_SIZE_759: usize = 2; +const IN_759: usize = 2; +const OUT_759: usize = 1; +fn aiur_fn_759( + inp: [G; IN_759], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_755], ExecError> { +) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63948,17 +64369,17 @@ fn aiur_fn_755( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_755] = [__v_1]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_1]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __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_755] = [__v_8]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_8]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63968,15 +64389,15 @@ fn aiur_fn_755( }) } -const INPUT_SIZE_756: usize = 1; -const IN_756: usize = 1; -const OUT_756: usize = 8; -fn aiur_fn_756( - inp: [G; IN_756], +const INPUT_SIZE_760: usize = 1; +const IN_760: usize = 1; +const OUT_760: usize = 8; +fn aiur_fn_760( + inp: [G; IN_760], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_756], ExecError> { +) -> Result<[G; OUT_760], 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 }; @@ -63993,12 +64414,12 @@ fn aiur_fn_756( 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_756] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -64016,8 +64437,8 @@ fn aiur_fn_756( 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_756] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64027,15 +64448,15 @@ fn aiur_fn_756( }) } -const INPUT_SIZE_757: usize = 8; -const IN_757: usize = 8; -const OUT_757: usize = 1; -fn aiur_fn_757( - inp: [G; IN_757], +const INPUT_SIZE_761: usize = 8; +const IN_761: usize = 8; +const OUT_761: usize = 1; +fn aiur_fn_761( + inp: [G; IN_761], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_757], ExecError> { +) -> Result<[G; OUT_761], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64047,8 +64468,8 @@ fn aiur_fn_757( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_757] = [__v_7]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_7]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64069,25 +64490,25 @@ fn aiur_fn_757( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_757] = [__v_21]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_21]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_757] = [__v_4]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_4]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_757] = [__v_22]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_22]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64101,37 +64522,37 @@ fn aiur_fn_757( }) } -const INPUT_SIZE_758: usize = 1; -const IN_758: usize = 1; -const OUT_758: usize = 1; -fn aiur_fn_758( - inp: [G; IN_758], +const INPUT_SIZE_762: usize = 1; +const IN_762: usize = 1; +const OUT_762: usize = 1; +fn aiur_fn_762( + inp: [G; IN_762], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_758], ExecError> { +) -> Result<[G; OUT_762], 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_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_758] = [__v_4]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_762] = [__v_4]; + if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_759: usize = 2; -const IN_759: usize = 2; -const OUT_759: usize = 1; -fn aiur_fn_759( - inp: [G; IN_759], +const INPUT_SIZE_763: usize = 2; +const IN_763: usize = 2; +const OUT_763: usize = 1; +fn aiur_fn_763( + inp: [G; IN_763], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_759], ExecError> { +) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64141,17 +64562,17 @@ fn aiur_fn_759( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_759] = [__v_1]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_1]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_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_759] = [__v_7]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_7]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64161,15 +64582,15 @@ fn aiur_fn_759( }) } -const INPUT_SIZE_760: usize = 1; -const IN_760: usize = 1; -const OUT_760: usize = 1; -fn aiur_fn_760( - inp: [G; IN_760], +const INPUT_SIZE_764: usize = 1; +const IN_764: usize = 1; +const OUT_764: usize = 1; +fn aiur_fn_764( + inp: [G; IN_764], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_760], ExecError> { +) -> Result<[G; OUT_764], 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 }; @@ -64179,17 +64600,17 @@ fn aiur_fn_760( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_760] = [__v_4]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_4]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_760] = [__v_6]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_6]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64199,15 +64620,15 @@ fn aiur_fn_760( }) } -const INPUT_SIZE_761: usize = 1; -const IN_761: usize = 1; -const OUT_761: usize = 8; -fn aiur_fn_761( - inp: [G; IN_761], +const INPUT_SIZE_765: usize = 1; +const IN_765: usize = 1; +const OUT_765: usize = 8; +fn aiur_fn_765( + inp: [G; IN_765], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_761], ExecError> { +) -> Result<[G; OUT_765], 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 }; @@ -64257,12 +64678,12 @@ fn aiur_fn_761( 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_761] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -64280,8 +64701,8 @@ fn aiur_fn_761( 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_761] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64291,19 +64712,19 @@ fn aiur_fn_761( }) } -const INPUT_SIZE_762: usize = 2; -const IN_762: usize = 2; -const OUT_762: usize = 1; -fn aiur_fn_762( - inp: [G; IN_762], +const INPUT_SIZE_766: usize = 2; +const IN_766: usize = 2; +const OUT_766: usize = 1; +fn aiur_fn_766( + inp: [G; IN_766], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_762], ExecError> { +) -> Result<[G; OUT_766], 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_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __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]; @@ -64311,8 +64732,8 @@ fn aiur_fn_762( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_762] = [__v_4]; - if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_4]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64322,15 +64743,15 @@ fn aiur_fn_762( }) } -const INPUT_SIZE_763: usize = 1; -const IN_763: usize = 1; -const OUT_763: usize = 1; -fn aiur_fn_763( - inp: [G; IN_763], +const INPUT_SIZE_767: usize = 1; +const IN_767: usize = 1; +const OUT_767: usize = 1; +fn aiur_fn_767( + inp: [G; IN_767], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_763], ExecError> { +) -> Result<[G; OUT_767], 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 }; @@ -64347,17 +64768,17 @@ fn aiur_fn_763( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_763] = [__v_11]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_11]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_763] = [__v_13]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_13]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64367,15 +64788,15 @@ fn aiur_fn_763( }) } -const INPUT_SIZE_764: usize = 9; -const IN_764: usize = 9; -const OUT_764: usize = 45; -fn aiur_fn_764( - inp: [G; IN_764], +const INPUT_SIZE_768: usize = 9; +const IN_768: usize = 9; +const OUT_768: usize = 45; +fn aiur_fn_768( + inp: [G; IN_768], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_764], ExecError> { +) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64440,8 +64861,8 @@ fn aiur_fn_764( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_764] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64454,7 +64875,7 @@ fn aiur_fn_764( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -64500,8 +64921,8 @@ fn aiur_fn_764( 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_764] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64516,15 +64937,15 @@ fn aiur_fn_764( }) } -const INPUT_SIZE_765: usize = 1; -const IN_765: usize = 1; -const OUT_765: usize = 8; -fn aiur_fn_765( - inp: [G; IN_765], +const INPUT_SIZE_769: usize = 1; +const IN_769: usize = 1; +const OUT_769: usize = 8; +fn aiur_fn_769( + inp: [G; IN_769], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_765], ExecError> { +) -> Result<[G; OUT_769], 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 }; @@ -64585,12 +65006,12 @@ fn aiur_fn_765( 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_765] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -64608,8 +65029,8 @@ fn aiur_fn_765( 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_765] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64619,15 +65040,15 @@ fn aiur_fn_765( }) } -const INPUT_SIZE_766: usize = 1; -const IN_766: usize = 1; -const OUT_766: usize = 8; -fn aiur_fn_766( - inp: [G; IN_766], +const INPUT_SIZE_770: usize = 1; +const IN_770: usize = 1; +const OUT_770: usize = 8; +fn aiur_fn_770( + inp: [G; IN_770], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_766], ExecError> { +) -> Result<[G; OUT_770], 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 }; @@ -64652,12 +65073,12 @@ fn aiur_fn_766( 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_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64675,8 +65096,8 @@ fn aiur_fn_766( 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_766] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64686,15 +65107,15 @@ fn aiur_fn_766( }) } -const INPUT_SIZE_767: usize = 9; -const IN_767: usize = 9; -const OUT_767: usize = 34; -fn aiur_fn_767( - inp: [G; IN_767], +const INPUT_SIZE_771: usize = 9; +const IN_771: usize = 9; +const OUT_771: usize = 34; +fn aiur_fn_771( + inp: [G; IN_771], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_767], ExecError> { +) -> Result<[G; OUT_771], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64748,8 +65169,8 @@ fn aiur_fn_767( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_767] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64762,7 +65183,7 @@ fn aiur_fn_767( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -64797,8 +65218,8 @@ fn aiur_fn_767( 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_767] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64813,15 +65234,15 @@ fn aiur_fn_767( }) } -const INPUT_SIZE_768: usize = 1; -const IN_768: usize = 1; -const OUT_768: usize = 1; -fn aiur_fn_768( - inp: [G; IN_768], +const INPUT_SIZE_772: usize = 1; +const IN_772: usize = 1; +const OUT_772: usize = 1; +fn aiur_fn_772( + inp: [G; IN_772], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_768], ExecError> { +) -> Result<[G; OUT_772], 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 }; @@ -64831,14 +65252,14 @@ fn aiur_fn_768( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_768] = [__v_4]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_4]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_768] = [__v_4]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_4]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64848,15 +65269,15 @@ fn aiur_fn_768( }) } -const INPUT_SIZE_769: usize = 5; -const IN_769: usize = 5; -const OUT_769: usize = 1; -fn aiur_fn_769( - inp: [G; IN_769], +const INPUT_SIZE_773: usize = 5; +const IN_773: usize = 5; +const OUT_773: usize = 1; +fn aiur_fn_773( + inp: [G; IN_773], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_769], ExecError> { +) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64877,17 +65298,17 @@ fn aiur_fn_769( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_769] = [__v_15]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_15]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_769] = [__v_13]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_13]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64897,15 +65318,15 @@ fn aiur_fn_769( }) } -const INPUT_SIZE_770: usize = 2; -const IN_770: usize = 2; -const OUT_770: usize = 1; -fn aiur_fn_770( - inp: [G; IN_770], +const INPUT_SIZE_774: usize = 2; +const IN_774: usize = 2; +const OUT_774: usize = 1; +fn aiur_fn_774( + inp: [G; IN_774], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_770], ExecError> { +) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64914,8 +65335,8 @@ fn aiur_fn_770( 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_770] = [__v_4]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_4]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64928,11 +65349,11 @@ fn aiur_fn_770( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_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_770] = [__v_9]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_9]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64944,28 +65365,28 @@ fn aiur_fn_770( }) } -const INPUT_SIZE_771: usize = 2; -const IN_771: usize = 2; -const OUT_771: usize = 1; -fn aiur_fn_771( - inp: [G; IN_771], +const INPUT_SIZE_775: usize = 2; +const IN_775: usize = 2; +const OUT_775: usize = 1; +fn aiur_fn_775( + inp: [G; IN_775], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_771], ExecError> { +) -> Result<[G; OUT_775], 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_771] = [__v_0]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_0]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __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]; @@ -64973,8 +65394,8 @@ fn aiur_fn_771( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_771] = [__v_7]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_7]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64986,15 +65407,15 @@ fn aiur_fn_771( }) } -const INPUT_SIZE_772: usize = 1; -const IN_772: usize = 1; -const OUT_772: usize = 1; -fn aiur_fn_772( - inp: [G; IN_772], +const INPUT_SIZE_776: usize = 1; +const IN_776: usize = 1; +const OUT_776: usize = 1; +fn aiur_fn_776( + inp: [G; IN_776], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_772], ExecError> { +) -> Result<[G; OUT_776], 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 }; @@ -65006,17 +65427,17 @@ fn aiur_fn_772( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_772] = [__v_6]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_6]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_772] = [__v_8]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_8]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65026,15 +65447,15 @@ fn aiur_fn_772( }) } -const INPUT_SIZE_773: usize = 8; -const IN_773: usize = 8; -const OUT_773: usize = 6; -fn aiur_fn_773( - inp: [G; IN_773], +const INPUT_SIZE_777: usize = 8; +const IN_777: usize = 8; +const OUT_777: usize = 6; +fn aiur_fn_777( + inp: [G; IN_777], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_773], ExecError> { +) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65044,7 +65465,7 @@ fn aiur_fn_773( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__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]; @@ -65055,8 +65476,8 @@ fn aiur_fn_773( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_773] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65066,15 +65487,15 @@ fn aiur_fn_773( }) } -const INPUT_SIZE_774: usize = 9; -const IN_774: usize = 9; -const OUT_774: usize = 1; -fn aiur_fn_774( - inp: [G; IN_774], +const INPUT_SIZE_778: usize = 9; +const IN_778: usize = 9; +const OUT_778: usize = 1; +fn aiur_fn_778( + inp: [G; IN_778], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_774], ExecError> { +) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65103,17 +65524,17 @@ fn aiur_fn_774( 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_774] = [__v_23]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_23]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __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_774] = [__v_21]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_21]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65123,15 +65544,15 @@ fn aiur_fn_774( }) } -const INPUT_SIZE_775: usize = 1; -const IN_775: usize = 1; -const OUT_775: usize = 1; -fn aiur_fn_775( - inp: [G; IN_775], +const INPUT_SIZE_779: usize = 1; +const IN_779: usize = 1; +const OUT_779: usize = 1; +fn aiur_fn_779( + inp: [G; IN_779], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_775], ExecError> { +) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; @@ -65144,17 +65565,17 @@ fn aiur_fn_775( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_775] = [__v_7]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_7]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_775] = [__v_9]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_9]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65164,15 +65585,15 @@ fn aiur_fn_775( }) } -const INPUT_SIZE_776: usize = 2; -const IN_776: usize = 2; -const OUT_776: usize = 1; -fn aiur_fn_776( - inp: [G; IN_776], +const INPUT_SIZE_780: usize = 2; +const IN_780: usize = 2; +const OUT_780: usize = 1; +fn aiur_fn_780( + inp: [G; IN_780], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_776], ExecError> { +) -> Result<[G; OUT_780], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65182,17 +65603,17 @@ fn aiur_fn_776( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_776] = [__v_1]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_780] = [__v_1]; + if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].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_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_776] = [__v_7]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_780] = [__v_7]; + if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65202,15 +65623,15 @@ fn aiur_fn_776( }) } -const INPUT_SIZE_777: usize = 8; -const IN_777: usize = 8; -const OUT_777: usize = 6; -fn aiur_fn_777( - inp: [G; IN_777], +const INPUT_SIZE_781: usize = 8; +const IN_781: usize = 8; +const OUT_781: usize = 6; +fn aiur_fn_781( + inp: [G; IN_781], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_777], ExecError> { +) -> Result<[G; OUT_781], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65230,8 +65651,8 @@ fn aiur_fn_777( 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_777] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -65252,22 +65673,22 @@ fn aiur_fn_777( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__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_777] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65277,27 +65698,27 @@ fn aiur_fn_777( 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_777] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__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_777] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65311,15 +65732,15 @@ fn aiur_fn_777( }) } -const INPUT_SIZE_778: usize = 15; -const IN_778: usize = 15; -const OUT_778: usize = 6; -fn aiur_fn_778( - inp: [G; IN_778], +const INPUT_SIZE_782: usize = 15; +const IN_782: usize = 15; +const OUT_782: usize = 6; +fn aiur_fn_782( + inp: [G; IN_782], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_778], ExecError> { +) -> Result<[G; OUT_782], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65338,38 +65759,38 @@ fn aiur_fn_778( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_783(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } } else { aiur_fn_783(__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_778] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_782] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].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_778] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_782] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_779: usize = 14; -const IN_779: usize = 14; -const OUT_779: usize = 6; -fn aiur_fn_779( - inp: [G; IN_779], +const INPUT_SIZE_783: usize = 14; +const IN_783: usize = 14; +const OUT_783: usize = 6; +fn aiur_fn_783( + inp: [G; IN_783], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_779], ExecError> { +) -> Result<[G; OUT_783], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65409,8 +65830,8 @@ fn aiur_fn_779( 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_779] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65434,8 +65855,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65463,8 +65884,8 @@ fn aiur_fn_779( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65488,8 +65909,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65497,8 +65918,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65508,8 +65929,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65537,8 +65958,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65546,8 +65967,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65557,8 +65978,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65570,8 +65991,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65581,8 +66002,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65614,8 +66035,8 @@ fn aiur_fn_779( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65639,8 +66060,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65648,8 +66069,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65659,8 +66080,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65688,8 +66109,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65697,8 +66118,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65708,8 +66129,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65721,8 +66142,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65732,8 +66153,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65763,8 +66184,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65792,8 +66213,8 @@ fn aiur_fn_779( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65817,8 +66238,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65826,8 +66247,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65837,8 +66258,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65866,8 +66287,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65875,8 +66296,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65886,8 +66307,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65899,8 +66320,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65910,8 +66331,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65943,8 +66364,8 @@ fn aiur_fn_779( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_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_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65968,8 +66389,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65977,8 +66398,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65988,8 +66409,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66017,8 +66438,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66026,8 +66447,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66037,8 +66458,8 @@ fn aiur_fn_779( 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_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66050,8 +66471,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66061,8 +66482,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66096,8 +66517,8 @@ fn aiur_fn_779( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_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_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66121,8 +66542,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66130,8 +66551,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66141,8 +66562,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66170,8 +66591,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66179,8 +66600,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66190,8 +66611,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66203,8 +66624,8 @@ fn aiur_fn_779( 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_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66214,8 +66635,8 @@ fn aiur_fn_779( 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_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66247,8 +66668,8 @@ fn aiur_fn_779( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_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_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66272,8 +66693,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66281,8 +66702,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66292,8 +66713,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66321,8 +66742,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66330,8 +66751,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66341,8 +66762,8 @@ fn aiur_fn_779( 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_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66354,8 +66775,8 @@ fn aiur_fn_779( 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_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66365,8 +66786,8 @@ fn aiur_fn_779( 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_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -70282,6 +70703,26 @@ pub(crate) fn execute_generated( let __out = aiur_fn_779(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 780u64 => { + let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_780(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 781u64 => { + let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_781(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 782u64 => { + let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_782(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 783u64 => { + let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_783(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); },